diff --git a/Casadi/Core/Classes/HomotopyNLPSolver.hs b/Casadi/Core/Classes/HomotopyNLPSolver.hs
--- a/Casadi/Core/Classes/HomotopyNLPSolver.hs
+++ b/Casadi/Core/Classes/HomotopyNLPSolver.hs
@@ -10,6 +10,8 @@
          HomotopyNLPSolver,
          HomotopyNLPSolverClass(..),
          homotopyNLPSolver,
+         homotopyNLPSolver_doc,
+         homotopyNLPSolver_loadPlugin,
        ) where
 
 
@@ -52,4 +54,44 @@
 -- 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__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/ImplicitFunction.hs b/Casadi/Core/Classes/ImplicitFunction.hs
--- a/Casadi/Core/Classes/ImplicitFunction.hs
+++ b/Casadi/Core/Classes/ImplicitFunction.hs
@@ -9,9 +9,15 @@
        (
          ImplicitFunction,
          ImplicitFunctionClass(..),
+         implicitFunction__0,
+         implicitFunction__1,
+         implicitFunction__2,
+         implicitFunction__3,
+         implicitFunction_doc,
          implicitFunction_getF,
          implicitFunction_getJac,
          implicitFunction_getLinsol,
+         implicitFunction_loadPlugin,
        ) where
 
 
@@ -37,6 +43,112 @@
 instance Show ImplicitFunction where
   show = unsafePerformIO . printableObject_getDescription
 -- direct wrapper
+foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__0" c_casadi__ImplicitFunction__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> IO (Ptr ImplicitFunction')
+casadi__ImplicitFunction__CONSTRUCTOR__0
+  :: String -> Function -> IO ImplicitFunction
+casadi__ImplicitFunction__CONSTRUCTOR__0 x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__0 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+implicitFunction__0 :: 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 Function' -> Ptr Function' -> IO (Ptr ImplicitFunction')
+casadi__ImplicitFunction__CONSTRUCTOR__1
+  :: String -> Function -> Function -> IO ImplicitFunction
+casadi__ImplicitFunction__CONSTRUCTOR__1 x0 x1 x2 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+implicitFunction__1 :: String -> Function -> Function -> 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) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr LinearSolver' -> IO (Ptr ImplicitFunction')
+casadi__ImplicitFunction__CONSTRUCTOR__2
+  :: String -> Function -> Function -> LinearSolver -> IO ImplicitFunction
+casadi__ImplicitFunction__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__ImplicitFunction__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
+implicitFunction__2 :: String -> Function -> Function -> LinearSolver -> IO ImplicitFunction
+implicitFunction__2 = casadi__ImplicitFunction__CONSTRUCTOR__2
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__3" c_casadi__ImplicitFunction__CONSTRUCTOR__3
+  :: Ptr (Ptr StdString) -> IO (Ptr ImplicitFunction')
+casadi__ImplicitFunction__CONSTRUCTOR__3
+  :: IO ImplicitFunction
+casadi__ImplicitFunction__CONSTRUCTOR__3  =
+
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__3 errStrPtrP 
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+implicitFunction__3 :: IO ImplicitFunction
+implicitFunction__3 = casadi__ImplicitFunction__CONSTRUCTOR__3
+
+
+-- 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
@@ -94,4 +206,24 @@
 -- 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__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
--- a/Casadi/Core/Classes/Integrator.hs
+++ b/Casadi/Core/Classes/Integrator.hs
@@ -9,14 +9,19 @@
        (
          Integrator,
          IntegratorClass(..),
-         integrator,
+         integrator__0,
+         integrator__1,
+         integrator__2,
          integrator_clone,
+         integrator_doc,
          integrator_getDAE,
          integrator_integrate,
          integrator_integrateB,
+         integrator_loadPlugin,
          integrator_printStats,
          integrator_reset,
          integrator_resetB,
+         integrator_setStopTime,
        ) where
 
 
@@ -42,23 +47,66 @@
 instance Show Integrator where
   show = unsafePerformIO . printableObject_getDescription
 -- direct wrapper
-foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR" c_casadi__Integrator__CONSTRUCTOR
+foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__0" c_casadi__Integrator__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> IO (Ptr Integrator')
+casadi__Integrator__CONSTRUCTOR__0
+  :: String -> Function -> IO Integrator
+casadi__Integrator__CONSTRUCTOR__0 x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__Integrator__CONSTRUCTOR__0 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+integrator__0 :: String -> Function -> 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 Function' -> Ptr Function' -> IO (Ptr Integrator')
+casadi__Integrator__CONSTRUCTOR__1
+  :: String -> Function -> Function -> IO Integrator
+casadi__Integrator__CONSTRUCTOR__1 x0 x1 x2 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__Integrator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+integrator__1 :: String -> Function -> Function -> 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) -> IO (Ptr Integrator')
-casadi__Integrator__CONSTRUCTOR
+casadi__Integrator__CONSTRUCTOR__2
   :: IO Integrator
-casadi__Integrator__CONSTRUCTOR  =
+casadi__Integrator__CONSTRUCTOR__2  =
 
   do
     errStrPtrP <- new nullPtr
-    ret <- c_casadi__Integrator__CONSTRUCTOR errStrPtrP 
+    ret <- c_casadi__Integrator__CONSTRUCTOR__2 errStrPtrP 
     errStrPtr <- peek errStrPtrP
     free errStrPtrP
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
 -- classy wrapper
-integrator :: IO Integrator
-integrator = casadi__Integrator__CONSTRUCTOR
+integrator__2 :: IO Integrator
+integrator__2 = casadi__Integrator__CONSTRUCTOR__2
 
 
 -- direct wrapper
@@ -82,6 +130,26 @@
 
 
 -- 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__getDAE" c_casadi__Integrator__getDAE
   :: Ptr (Ptr StdString) -> Ptr Integrator' -> IO (Ptr Function')
 casadi__Integrator__getDAE
@@ -144,6 +212,26 @@
 
 
 -- 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
@@ -201,4 +289,25 @@
 -- 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/LPSolver.hs b/Casadi/Core/Classes/LPSolver.hs
--- a/Casadi/Core/Classes/LPSolver.hs
+++ b/Casadi/Core/Classes/LPSolver.hs
@@ -10,6 +10,8 @@
          LPSolver,
          LPSolverClass(..),
          lpSolver,
+         lpSolver_doc,
+         lpSolver_loadPlugin,
        ) where
 
 
@@ -52,4 +54,44 @@
 -- classy wrapper
 lpSolver :: IO LPSolver
 lpSolver = casadi__LPSolver__CONSTRUCTOR
+
+
+-- 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__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/LinearSolver.hs b/Casadi/Core/Classes/LinearSolver.hs
--- a/Casadi/Core/Classes/LinearSolver.hs
+++ b/Casadi/Core/Classes/LinearSolver.hs
@@ -11,6 +11,14 @@
          LinearSolverClass(..),
          linearSolver__0,
          linearSolver__1,
+         linearSolver__2,
+         linearSolver__3,
+         linearSolver_doc,
+         linearSolver_getFactorizationSparsity__0,
+         linearSolver_getFactorizationSparsity__1,
+         linearSolver_getFactorization__0,
+         linearSolver_getFactorization__1,
+         linearSolver_loadPlugin,
          linearSolver_prepare,
          linearSolver_prepared,
          linearSolver_solve__0,
@@ -43,43 +51,208 @@
   show = unsafePerformIO . printableObject_getDescription
 -- direct wrapper
 foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__0" c_casadi__LinearSolver__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr LinearSolver')
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr LinearSolver')
 casadi__LinearSolver__CONSTRUCTOR__0
-  :: Sparsity -> IO LinearSolver
-casadi__LinearSolver__CONSTRUCTOR__0 x0 =
+  :: String -> Sparsity -> IO LinearSolver
+casadi__LinearSolver__CONSTRUCTOR__0 x0 x1 =
   withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
   do
     errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__CONSTRUCTOR__0 errStrPtrP x0'
+    ret <- c_casadi__LinearSolver__CONSTRUCTOR__0 errStrPtrP x0' x1'
     errStrPtr <- peek errStrPtrP
     free errStrPtrP
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
 -- classy wrapper
-linearSolver__0 :: Sparsity -> IO LinearSolver
+linearSolver__0 :: String -> Sparsity -> 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 Sparsity' -> CInt -> IO (Ptr LinearSolver')
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver')
 casadi__LinearSolver__CONSTRUCTOR__1
-  :: Sparsity -> Int -> IO LinearSolver
-casadi__LinearSolver__CONSTRUCTOR__1 x0 x1 =
+  :: String -> Sparsity -> Int -> IO LinearSolver
+casadi__LinearSolver__CONSTRUCTOR__1 x0 x1 x2 =
   withMarshal x0 $ \x0' ->
   withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
   do
     errStrPtrP <- new nullPtr
-    ret <- c_casadi__LinearSolver__CONSTRUCTOR__1 errStrPtrP x0' x1'
+    ret <- c_casadi__LinearSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2'
     errStrPtr <- peek errStrPtrP
     free errStrPtrP
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
 -- classy wrapper
-linearSolver__1 :: Sparsity -> Int -> IO LinearSolver
+linearSolver__1 :: String -> Sparsity -> Int -> 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 Sparsity' -> IO (Ptr LinearSolver')
+casadi__LinearSolver__CONSTRUCTOR__2
+  :: Sparsity -> IO LinearSolver
+casadi__LinearSolver__CONSTRUCTOR__2 x0 =
+  withMarshal x0 $ \x0' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__LinearSolver__CONSTRUCTOR__2 errStrPtrP x0'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+linearSolver__2 :: 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 Sparsity' -> CInt -> IO (Ptr LinearSolver')
+casadi__LinearSolver__CONSTRUCTOR__3
+  :: Sparsity -> Int -> IO LinearSolver
+casadi__LinearSolver__CONSTRUCTOR__3 x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__LinearSolver__CONSTRUCTOR__3 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+linearSolver__3 :: Sparsity -> Int -> 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__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
diff --git a/Casadi/Core/Classes/NLPSolver.hs b/Casadi/Core/Classes/NLPSolver.hs
--- a/Casadi/Core/Classes/NLPSolver.hs
+++ b/Casadi/Core/Classes/NLPSolver.hs
@@ -9,14 +9,19 @@
        (
          NLPSolver,
          NLPSolverClass(..),
-         nlpSolver,
+         nlpSolver__0,
+         nlpSolver__1,
+         nlpSolver_doc,
+         nlpSolver_getReducedHessian,
          nlpSolver_getReportConstraints,
          nlpSolver_gradF,
          nlpSolver_hessLag,
          nlpSolver_jacG,
          nlpSolver_joinFG,
+         nlpSolver_loadPlugin,
          nlpSolver_nlp,
          nlpSolver_reportConstraints,
+         nlpSolver_setOptionsFromFile,
          nlpSolver_setQPOptions,
        ) where
 
@@ -43,26 +48,87 @@
 instance Show NLPSolver where
   show = unsafePerformIO . printableObject_getDescription
 -- direct wrapper
-foreign import ccall unsafe "casadi__NLPSolver__CONSTRUCTOR" c_casadi__NLPSolver__CONSTRUCTOR
+foreign import ccall unsafe "casadi__NLPSolver__CONSTRUCTOR__0" c_casadi__NLPSolver__CONSTRUCTOR__0
+  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> IO (Ptr NLPSolver')
+casadi__NLPSolver__CONSTRUCTOR__0
+  :: String -> Function -> IO NLPSolver
+casadi__NLPSolver__CONSTRUCTOR__0 x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__NLPSolver__CONSTRUCTOR__0 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+nlpSolver__0 :: String -> Function -> 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) -> IO (Ptr NLPSolver')
-casadi__NLPSolver__CONSTRUCTOR
+casadi__NLPSolver__CONSTRUCTOR__1
   :: IO NLPSolver
-casadi__NLPSolver__CONSTRUCTOR  =
+casadi__NLPSolver__CONSTRUCTOR__1  =
 
   do
     errStrPtrP <- new nullPtr
-    ret <- c_casadi__NLPSolver__CONSTRUCTOR errStrPtrP 
+    ret <- c_casadi__NLPSolver__CONSTRUCTOR__1 errStrPtrP 
     errStrPtr <- peek errStrPtrP
     free errStrPtrP
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
 -- classy wrapper
-nlpSolver :: IO NLPSolver
-nlpSolver = casadi__NLPSolver__CONSTRUCTOR
+nlpSolver__1 :: IO NLPSolver
+nlpSolver__1 = casadi__NLPSolver__CONSTRUCTOR__1
 
 
 -- 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
@@ -164,6 +230,26 @@
 
 
 -- 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
@@ -201,6 +287,27 @@
 -- 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)
 
 
 -- direct wrapper
diff --git a/Casadi/Core/Classes/QCQPSolver.hs b/Casadi/Core/Classes/QCQPSolver.hs
--- a/Casadi/Core/Classes/QCQPSolver.hs
+++ b/Casadi/Core/Classes/QCQPSolver.hs
@@ -10,6 +10,8 @@
          QCQPSolver,
          QCQPSolverClass(..),
          qcqpSolver,
+         qcqpSolver_doc,
+         qcqpSolver_loadPlugin,
          qcqpSolver_setQPOptions,
        ) where
 
@@ -53,6 +55,46 @@
 -- classy wrapper
 qcqpSolver :: IO QCQPSolver
 qcqpSolver = casadi__QCQPSolver__CONSTRUCTOR
+
+
+-- 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__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
 
 
 -- direct wrapper
diff --git a/Casadi/Core/Classes/QPSolver.hs b/Casadi/Core/Classes/QPSolver.hs
--- a/Casadi/Core/Classes/QPSolver.hs
+++ b/Casadi/Core/Classes/QPSolver.hs
@@ -10,7 +10,9 @@
          QPSolver,
          QPSolverClass(..),
          qpSolver,
+         qpSolver_doc,
          qpSolver_generateNativeCode,
+         qpSolver_loadPlugin,
          qpSolver_setLPOptions,
        ) where
 
@@ -57,6 +59,26 @@
 
 
 -- 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
@@ -75,6 +97,26 @@
 -- 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__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
 
 
 -- direct wrapper
diff --git a/Casadi/Core/Classes/SDPSolver.hs b/Casadi/Core/Classes/SDPSolver.hs
--- a/Casadi/Core/Classes/SDPSolver.hs
+++ b/Casadi/Core/Classes/SDPSolver.hs
@@ -10,6 +10,8 @@
          SDPSolver,
          SDPSolverClass(..),
          sdpSolver,
+         sdpSolver_doc,
+         sdpSolver_loadPlugin,
          sdpSolver_setSOCPOptions,
        ) where
 
@@ -53,6 +55,46 @@
 -- classy wrapper
 sdpSolver :: IO SDPSolver
 sdpSolver = casadi__SDPSolver__CONSTRUCTOR
+
+
+-- 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__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
 
 
 -- direct wrapper
diff --git a/Casadi/Core/Classes/SDQPSolver.hs b/Casadi/Core/Classes/SDQPSolver.hs
--- a/Casadi/Core/Classes/SDQPSolver.hs
+++ b/Casadi/Core/Classes/SDQPSolver.hs
@@ -10,6 +10,8 @@
          SDQPSolver,
          SDQPSolverClass(..),
          sdqpSolver,
+         sdqpSolver_doc,
+         sdqpSolver_loadPlugin,
          sdqpSolver_setSOCQPOptions,
        ) where
 
@@ -53,6 +55,46 @@
 -- classy wrapper
 sdqpSolver :: IO SDQPSolver
 sdqpSolver = casadi__SDQPSolver__CONSTRUCTOR
+
+
+-- 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__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
 
 
 -- direct wrapper
diff --git a/Casadi/Core/Classes/SOCPSolver.hs b/Casadi/Core/Classes/SOCPSolver.hs
--- a/Casadi/Core/Classes/SOCPSolver.hs
+++ b/Casadi/Core/Classes/SOCPSolver.hs
@@ -10,6 +10,8 @@
          SOCPSolver,
          SOCPSolverClass(..),
          socpSolver,
+         socpSolver_doc,
+         socpSolver_loadPlugin,
        ) where
 
 
@@ -52,4 +54,44 @@
 -- classy wrapper
 socpSolver :: IO SOCPSolver
 socpSolver = casadi__SOCPSolver__CONSTRUCTOR
+
+
+-- 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__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/StabilizedQPSolver.hs b/Casadi/Core/Classes/StabilizedQPSolver.hs
--- a/Casadi/Core/Classes/StabilizedQPSolver.hs
+++ b/Casadi/Core/Classes/StabilizedQPSolver.hs
@@ -10,7 +10,9 @@
          StabilizedQPSolver,
          StabilizedQPSolverClass(..),
          stabilizedQPSolver,
+         stabilizedQPSolver_doc,
          stabilizedQPSolver_generateNativeCode,
+         stabilizedQPSolver_loadPlugin,
          stabilizedQPSolver_setLPOptions,
        ) where
 
@@ -57,6 +59,26 @@
 
 
 -- 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
@@ -75,6 +97,26 @@
 -- 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__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
 
 
 -- direct wrapper
diff --git a/Casadi/Core/Classes/SymbolicNLP.hs b/Casadi/Core/Classes/SymbolicNLP.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/SymbolicNLP.hs
@@ -0,0 +1,56 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.SymbolicNLP
+       (
+         SymbolicNLP,
+         SymbolicNLPClass(..),
+         symbolicNLP_parseNL,
+       ) where
+
+
+import Prelude hiding ( Functor )
+
+import Data.Vector ( Vector )
+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.Core.Classes.PrintableObject
+import Casadi.Internal.CToolsInstances ( )
+import Casadi.Internal.FormatException ( formatException )
+import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
+import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
+import Casadi.Internal.WrapReturn ( WrapReturn(..) )
+import Casadi.Core.Data
+import Casadi.Core.Enums
+
+instance Show SymbolicNLP where
+  show = unsafePerformIO . printableObject_getDescription
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicNLP__parseNL" c_casadi__SymbolicNLP__parseNL
+  :: Ptr (Ptr StdString) -> Ptr SymbolicNLP' -> Ptr StdString -> IO ()
+casadi__SymbolicNLP__parseNL
+  :: SymbolicNLP -> String -> IO ()
+casadi__SymbolicNLP__parseNL x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_casadi__SymbolicNLP__parseNL errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicNLP_parseNL :: SymbolicNLPClass a => a -> String -> IO ()
+symbolicNLP_parseNL x = casadi__SymbolicNLP__parseNL (castSymbolicNLP x)
+
diff --git a/Casadi/Core/Classes/SymbolicQR.hs b/Casadi/Core/Classes/SymbolicQR.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/SymbolicQR.hs
+++ /dev/null
@@ -1,120 +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.SymbolicQR
-       (
-         SymbolicQR,
-         SymbolicQRClass(..),
-         symbolicQR__0,
-         symbolicQR__1,
-         symbolicQR__2,
-         symbolicQR_creator,
-       ) where
-
-
-import Prelude hiding ( Functor )
-
-import Data.Vector ( Vector )
-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.Core.Classes.PrintableObject
-import Casadi.Internal.CToolsInstances ( )
-import Casadi.Internal.FormatException ( formatException )
-import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
-import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
-import Casadi.Internal.WrapReturn ( WrapReturn(..) )
-import Casadi.Core.Data
-import Casadi.Core.Enums
-
-instance Show SymbolicQR where
-  show = unsafePerformIO . printableObject_getDescription
--- direct wrapper
-foreign import ccall unsafe "casadi__SymbolicQR__CONSTRUCTOR__0" c_casadi__SymbolicQR__CONSTRUCTOR__0
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SymbolicQR')
-casadi__SymbolicQR__CONSTRUCTOR__0
-  :: Sparsity -> IO SymbolicQR
-casadi__SymbolicQR__CONSTRUCTOR__0 x0 =
-  withMarshal x0 $ \x0' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SymbolicQR__CONSTRUCTOR__0 errStrPtrP x0'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-symbolicQR__0 :: Sparsity -> IO SymbolicQR
-symbolicQR__0 = casadi__SymbolicQR__CONSTRUCTOR__0
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SymbolicQR__CONSTRUCTOR__1" c_casadi__SymbolicQR__CONSTRUCTOR__1
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr SymbolicQR')
-casadi__SymbolicQR__CONSTRUCTOR__1
-  :: Sparsity -> Int -> IO SymbolicQR
-casadi__SymbolicQR__CONSTRUCTOR__1 x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SymbolicQR__CONSTRUCTOR__1 errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-symbolicQR__1 :: Sparsity -> Int -> IO SymbolicQR
-symbolicQR__1 = casadi__SymbolicQR__CONSTRUCTOR__1
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SymbolicQR__CONSTRUCTOR__2" c_casadi__SymbolicQR__CONSTRUCTOR__2
-  :: Ptr (Ptr StdString) -> IO (Ptr SymbolicQR')
-casadi__SymbolicQR__CONSTRUCTOR__2
-  :: IO SymbolicQR
-casadi__SymbolicQR__CONSTRUCTOR__2  =
-
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SymbolicQR__CONSTRUCTOR__2 errStrPtrP 
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-symbolicQR__2 :: IO SymbolicQR
-symbolicQR__2 = casadi__SymbolicQR__CONSTRUCTOR__2
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SymbolicQR__creator" c_casadi__SymbolicQR__creator
-  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver')
-casadi__SymbolicQR__creator
-  :: Sparsity -> Int -> IO LinearSolver
-casadi__SymbolicQR__creator x0 x1 =
-  withMarshal x0 $ \x0' ->
-  withMarshal x1 $ \x1' ->
-  do
-    errStrPtrP <- new nullPtr
-    ret <- c_casadi__SymbolicQR__creator errStrPtrP x0' x1'
-    errStrPtr <- peek errStrPtrP
-    free errStrPtrP
-    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-symbolicQR_creator :: Sparsity -> Int -> IO LinearSolver
-symbolicQR_creator = casadi__SymbolicQR__creator
-
diff --git a/Casadi/Core/Data.hs b/Casadi/Core/Data.hs
--- a/Casadi/Core/Data.hs
+++ b/Casadi/Core/Data.hs
@@ -228,8 +228,8 @@
 >|              |              |              | don't make   |              |
 >|              |              |              | sense        |              |
 >+--------------+--------------+--------------+--------------+--------------+
->| integrator   | OT_INTEGRATO | GenericType( | An           | casadi::Cont |
->|              | R            | )            | integrator   | rolSimulator |
+>| integrator   | OT_STRING    | GenericType( | An           | casadi::Cont |
+>|              |              | )            | integrator   | rolSimulator |
 >|              |              |              | creator      | Internal     |
 >|              |              |              | function     |              |
 >+--------------+--------------+--------------+--------------+--------------+
@@ -1333,8 +1333,8 @@
 >|              |              |              | don't make   |              |
 >|              |              |              | sense        |              |
 >+--------------+--------------+--------------+--------------+--------------+
->| linear_solve | OT_LINEARSOL | GenericType( | User-defined | casadi::Impl |
->| r            | VER          | )            | linear       | icitFunction |
+>| linear_solve | OT_STRING    | GenericType( | User-defined | casadi::Impl |
+>| r            |              | )            | linear       | icitFunction |
 >|              |              |              | solver       | Internal     |
 >|              |              |              | class.       |              |
 >|              |              |              | Needed for s |              |
@@ -1661,10 +1661,10 @@
 >
 >Solves the following linear problem:
 >
->min          c' x  x  subject to             LBA <= A x <= UBA LBX <= x   <=
->UBX      with x ( n x 1)          c ( n x 1 )          A sparse matrix ( nc
->x n)          LBA, UBA dense vector (nc x 1) LBX, UBX dense vector (n x 1)
->n: number of decision variables (x) nc: number of constraints (A)
+>min          c' x x  subject to LBA <= A x <= UBA LBX <= x   <= UBX with x (
+>n x 1) c ( n x 1 ) A sparse matrix ( nc x n) LBA, UBA dense vector (nc x 1)
+>LBX, UBX dense vector (n x 1)  n: number of decision variables (x) nc:
+>number of constraints (A)
 >
 >Joris Gillis
 >
@@ -2262,6 +2262,14 @@
 >|              |              |              | erivativeGen |              |
 >|              |              |              | erator .     |              |
 >+--------------+--------------+--------------+--------------+--------------+
+>| eval_errors_ | OT_BOOLEAN   | false        | When errors  | casadi::NLPS |
+>| fatal        |              |              | occur during | olverInterna |
+>|              |              |              | evaluation   | l            |
+>|              |              |              | of           |              |
+>|              |              |              | f,g,...,stop |              |
+>|              |              |              | the          |              |
+>|              |              |              | iterations   |              |
+>+--------------+--------------+--------------+--------------+--------------+
 >| expand       | OT_BOOLEAN   | false        | Expand the   | casadi::NLPS |
 >|              |              |              | NLP function | olverInterna |
 >|              |              |              | in terms of  | l            |
@@ -3022,11 +3030,11 @@
 >
 >Solves the following strictly convex problem:
 >
->min          1/2 x' H x + g' x  x  subject to             1/2 x' Pi x +  qi'
->x + ri  <= 0   for i=0..nq-1             LBA <= A x <= UBA LBX <= x   <= UBX
->with :       H, Pi sparse (n x n) positive definite       g, qi dense  (n x
->1)       ri scalar      n: number of decision variables (x)     nc: number
->of linear constraints (A) nq: number of quadratic constraints
+>min          1/2 x' H x + g' x x  subject to 1/2 x' Pi x  +  qi' x + ri  <=
+>0   for i=0..nq-1 LBA <= A x <= UBA LBX <= x   <= UBX  with : H, Pi sparse
+>(n x n) positive definite g, qi dense  (n x 1) ri scalar n: number of
+>decision variables (x) nc: number of linear constraints (A) nq: number of
+>quadratic constraints
 >
 >If H, Pi is not positive-definite, the solver should throw an error.
 >
@@ -3422,32 +3430,31 @@
 >
 >Primal:
 >
->min          c' x  x subject to               P = Sum_i^m F_i x_i - G P
->negative semidefinite              LBA <= A x <= UBA             LBX <= x
-><= UBX      with x ( n x 1)          c ( n x 1 )          G, F_i  sparse
->symmetric (m x m)          X dense symmetric ( m x m ) A sparse matrix ( nc
->x n)          LBA, UBA dense vector (nc x 1) LBX, UBX dense vector (n x 1)
+>min          c' x x subject to P = Sum_i^m F_i x_i - G P negative
+>semidefinite  LBA <= A x <= UBA LBX <= x   <= UBX  with x ( n x 1) c ( n x 1
+>) G, F_i  sparse symmetric (m x m) X dense symmetric ( m x m ) A sparse
+>matrix ( nc x n) LBA, UBA dense vector (nc x 1) LBX, UBX dense vector (n x
+>1)
 >
 >This formulation is chosen as primal, because it does not call for a large
 >decision variable space.
 >
 >Dual:
 >
->max          trace(G Y)  Y  subject to             trace(F_i Y) = c_i Y
->positive semidefinite      with Y dense symmetric ( m x m)
+>max          trace(G Y) Y  subject to trace(F_i Y) = c_i Y positive
+>semidefinite  with Y dense symmetric ( m x m)
 >
 >On generality: you might have formulation with block partitioning:
 >
 >Primal:
 >
->min          c' x  x subject to               Pj = Sum_i^m F_ij x_i - gj
->for all j               Pj negative semidefinite   for all j with x ( n x 1)
->c ( n x 1 )          G, F_i  sparse symmetric (m x m)          X dense
->symmetric ( m x m )
+>min          c' x x subject to Pj = Sum_i^m F_ij x_i - gj   for all j Pj
+>negative semidefinite   for all j  with x ( n x 1) c ( n x 1 ) G, F_i
+>sparse symmetric (m x m) X dense symmetric ( m x m )
 >
->Dual:max          Sum_j trace(Gj Yj)  Yj  subject to             Sum_j
->trace(F_ij Yj) = c_i   for all j             Yj positive semidefinite for
->all j      with Y dense symmetric ( m x m)
+>Dual:max          Sum_j trace(Gj Yj) Yj  subject to Sum_j trace(F_ij Yj) =
+>c_i   for all j Yj positive semidefinite     for all j  with Y dense
+>symmetric ( m x m)
 >
 >You can cast this into the standard form with: G = blkdiag(Gj for all j) Fi
 >= blkdiag(F_ij for all j)
@@ -3830,7 +3837,7 @@
 >|              |              |              | during       |              |
 >|              |              |              | evaluation   |              |
 >+--------------+--------------+--------------+--------------+--------------+
->| sdp_solver   | OT_SDPSOLVER | GenericType( | The          | casadi::SDQP |
+>| sdp_solver   | OT_STRING    | GenericType( | The          | casadi::SDQP |
 >|              |              | )            | SDQPSolver   | SolverIntern |
 >|              |              |              | used to      | al           |
 >|              |              |              | solve the    |              |
@@ -3905,12 +3912,11 @@
 >
 >Primal:
 >
->min          c' x  x subject to               || Gi' x + hi ||_2 <= ei' x +
->fi  i = 1..m              LBA <= A x <= UBA             LBX <= x   <= UBX
->with x ( n x 1)          c ( n x 1 )          Gi sparse (n x ni)          hi
->dense (ni x 1)          ei  dense (n x 1) fi  dense (1 x 1)          N =
->Sum_i^m ni          A sparse (nc x n) LBA, UBA dense vector (nc x 1)
->LBX, UBX dense vector (n x 1)
+>min          c' x x subject to || Gi' x + hi ||_2 <= ei' x + fi  i = 1..m
+>LBA <= A x <= UBA LBX <= x   <= UBX  with x ( n x 1) c ( n x 1 ) Gi  sparse
+>(n x ni) hi  dense (ni x 1) ei  dense (n x 1) fi  dense (1 x 1) N = Sum_i^m
+>ni A sparse (nc x n) LBA, UBA dense vector (nc x 1) LBX, UBX dense vector (n
+>x 1)
 >
 >Joris Gillis
 >
@@ -4667,10 +4673,9 @@
 >
 >Solves the following strictly convex problem:
 >
->min          1/2 x' H x + g' x  x  subject to             LBA <= A x <= UBA
->LBX <= x   <= UBX      with :       H sparse (n x n) positive definite
->g dense  (n x 1)      n: number of decision variables (x)     nc: number of
->constraints (A)
+>min          1/2 x' H x + g' x x  subject to LBA <= A x <= UBA LBX <= x   <=
+>UBX  with : H sparse (n x n) positive definite g dense  (n x 1) n: number of
+>decision variables (x) nc: number of constraints (A)
 >
 >If H is not positive-definite, the solver should throw an error.
 >
@@ -4865,170 +4870,35 @@
 
 
 -- raw decl
-data SymbolicQR'
+data SymbolicNLP'
 -- data decl
 {-|
->LinearSolver based on QR factorization with sparsity pattern based
->reordering without partial pivoting.
->
->Solves the linear system A*X = B or A^T*X = B for X with A square and non-
->singular
->
->If A is structurally singular, an error will be thrown during init. If A is
->numerically singular, the prepare step will fail. Joel Andersson
->
->>Input scheme: casadi::LinsolInput (LINSOL_NUM_IN = 3) [linsolIn]
->+-----------+-------+------------------------------------------------+
->| Full name | Short |                  Description                   |
->+===========+=======+================================================+
->| LINSOL_A  | A     | The square matrix A: sparse, (n x n). .        |
->+-----------+-------+------------------------------------------------+
->| LINSOL_B  | B     | The right-hand-side matrix b: dense, (n x m) . |
->+-----------+-------+------------------------------------------------+
->
->>Output scheme: casadi::LinsolOutput (LINSOL_NUM_OUT = 2) [linsolOut]
->+-----------+-------+----------------------------------------------+
->| Full name | Short |                 Description                  |
->+===========+=======+==============================================+
->| LINSOL_X  | X     | Solution to the linear system of equations . |
->+-----------+-------+----------------------------------------------+
->
->>List of available options
->+--------------+--------------+--------------+--------------+--------------+
->|      Id      |     Type     |   Default    | Description  |   Used in    |
->+==============+==============+==============+==============+==============+
->| ad_mode      | OT_STRING    | "automatic"  | How to       | casadi::Func |
->|              |              |              | calculate    | tionInternal |
->|              |              |              | the          |              |
->|              |              |              | Jacobians.   |              |
->|              |              |              | (forward:    |              |
->|              |              |              | only forward |              |
->|              |              |              | mode|reverse |              |
->|              |              |              | : only       |              |
->|              |              |              | adjoint mode |              |
->|              |              |              | |automatic:  |              |
->|              |              |              | a heuristic  |              |
->|              |              |              | decides      |              |
->|              |              |              | which is     |              |
->|              |              |              | more         |              |
->|              |              |              | appropriate) |              |
->+--------------+--------------+--------------+--------------+--------------+
->| codegen      | OT_BOOLEAN   | false        | C-code       | casadi::Symb |
->|              |              |              | generation   | olicQRIntern |
->|              |              |              |              | al           |
->+--------------+--------------+--------------+--------------+--------------+
->| compiler     | OT_STRING    | "gcc -fPIC   | Compiler     | casadi::Symb |
->|              |              | -O2"         | command to   | olicQRIntern |
->|              |              |              | be used for  | al           |
->|              |              |              | compiling    |              |
->|              |              |              | generated    |              |
->|              |              |              | code         |              |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function     | casadi::Func |
->| enerator     | EGENERATOR   | )            | that returns | tionInternal |
->|              |              |              | a derivative |              |
->|              |              |              | function     |              |
->|              |              |              | given a      |              |
->|              |              |              | number of    |              |
->|              |              |              | forward and  |              |
->|              |              |              | reverse      |              |
->|              |              |              | directional  |              |
->|              |              |              | derivative,  |              |
->|              |              |              | overrides    |              |
->|              |              |              | internal     |              |
->|              |              |              | routines.    |              |
->|              |              |              | Check docume |              |
->|              |              |              | ntation of D |              |
->|              |              |              | erivativeGen |              |
->|              |              |              | erator .     |              |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN   | false        | Flag to      | casadi::Func |
->|              |              |              | indicate     | tionInternal |
->|              |              |              | whether      |              |
->|              |              |              | statistics   |              |
->|              |              |              | must be      |              |
->|              |              |              | gathered     |              |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN   | true         | Throw        | casadi::Func |
->|              |              |              | exceptions   | tionInternal |
->|              |              |              | when the     |              |
->|              |              |              | numerical    |              |
->|              |              |              | values of    |              |
->|              |              |              | the inputs   |              |
->|              |              |              | don't make   |              |
->|              |              |              | sense        |              |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor      | OT_STRINGVEC | GenericType( | Monitors to  | casadi::Func |
->|              | TOR          | )            | be activated | tionInternal |
->|              |              |              | (inputs|outp |              |
->|              |              |              | uts)         |              |
->+--------------+--------------+--------------+--------------+--------------+
->| name         | OT_STRING    | "unnamed_sha | name of the  | casadi::Opti |
->|              |              | red_object"  | object       | onsFunctiona |
->|              |              |              |              | lityNode     |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN   | true         | Throw        | casadi::Func |
->| heck         |              |              | exceptions   | tionInternal |
->|              |              |              | when NaN or  |              |
->|              |              |              | Inf appears  |              |
->|              |              |              | during       |              |
->|              |              |              | evaluation   |              |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data    | OT_VOIDPTR   | GenericType( | A user-      | casadi::Func |
->|              |              | )            | defined      | tionInternal |
->|              |              |              | field that   |              |
->|              |              |              | can be used  |              |
->|              |              |              | to identify  |              |
->|              |              |              | the function |              |
->|              |              |              | or pass      |              |
->|              |              |              | additional   |              |
->|              |              |              | information  |              |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose      | OT_BOOLEAN   | false        | Verbose      | casadi::Func |
->|              |              |              | evaluation   | tionInternal |
->|              |              |              | for          |              |
->|              |              |              | debugging    |              |
->+--------------+--------------+--------------+--------------+--------------+
+>A symbolic NLP representation.
 >
->Diagrams
+>Joel Andersson
 >
->C++ includes: symbolic_qr.hpp 
+>C++ includes: symbolic_nlp.hpp 
 -}
-newtype SymbolicQR = SymbolicQR (ForeignPtr SymbolicQR')
+newtype SymbolicNLP = SymbolicNLP (ForeignPtr SymbolicNLP')
 -- typeclass decl
-class SymbolicQRClass a where
-  castSymbolicQR :: a -> SymbolicQR
-instance SymbolicQRClass SymbolicQR where
-  castSymbolicQR = id
+class SymbolicNLPClass a where
+  castSymbolicNLP :: a -> SymbolicNLP
+instance SymbolicNLPClass SymbolicNLP where
+  castSymbolicNLP = id
 
 -- baseclass instances
-instance FunctionClass SymbolicQR where
-  castFunction (SymbolicQR x) = Function (castForeignPtr x)
-
-instance LinearSolverClass SymbolicQR where
-  castLinearSolver (SymbolicQR x) = LinearSolver (castForeignPtr x)
-
-instance OptionsFunctionalityClass SymbolicQR where
-  castOptionsFunctionality (SymbolicQR x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass SymbolicQR where
-  castPrintableObject (SymbolicQR x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass SymbolicQR where
-  castSharedObject (SymbolicQR x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SymbolicQR where
-  castIOInterfaceFunction (SymbolicQR x) = IOInterfaceFunction (castForeignPtr x)
+instance PrintableObjectClass SymbolicNLP where
+  castPrintableObject (SymbolicNLP x) = PrintableObject (castForeignPtr x)
 
 
 -- helper instances
-instance Marshal SymbolicQR (Ptr SymbolicQR') where
-  marshal (SymbolicQR x) = return (unsafeForeignPtrToPtr x)
-  marshalFree (SymbolicQR x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SymbolicQR" 
-  c_delete_casadi__SymbolicQR :: FunPtr (Ptr SymbolicQR' -> IO ())
-instance WrapReturn (Ptr SymbolicQR') SymbolicQR where
-  wrapReturn = (fmap SymbolicQR) . (newForeignPtr c_delete_casadi__SymbolicQR)
+instance Marshal SymbolicNLP (Ptr SymbolicNLP') where
+  marshal (SymbolicNLP x) = return (unsafeForeignPtrToPtr x)
+  marshalFree (SymbolicNLP x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SymbolicNLP" 
+  c_delete_casadi__SymbolicNLP :: FunPtr (Ptr SymbolicNLP' -> IO ())
+instance WrapReturn (Ptr SymbolicNLP') SymbolicNLP where
+  wrapReturn = (fmap SymbolicNLP) . (newForeignPtr c_delete_casadi__SymbolicNLP)
 
 
 -- raw decl
diff --git a/Casadi/Core/Enums.hs b/Casadi/Core/Enums.hs
--- a/Casadi/Core/Enums.hs
+++ b/Casadi/Core/Enums.hs
@@ -4,6 +4,7 @@
 
 module Casadi.Core.Enums
        (
+         CollocationPoints(..),
          ControlSimulatorInput(..),
          ControlledDAEInput(..),
          DAEInput(..),
@@ -59,6 +60,23 @@
 import Casadi.Internal.Marshal ( Marshal(..) )
 import Casadi.Internal.WrapReturn ( WrapReturn(..) )
 
+-- EnumDecl: CollocationPoints
+data CollocationPoints = LEGENDRE
+                       | RADAU
+                       deriving (Show, Eq)
+instance Enum CollocationPoints where
+        fromEnum (LEGENDRE) = 0
+        fromEnum (RADAU) = 1
+        toEnum (0) = LEGENDRE
+        toEnum (1) = RADAU
+        toEnum k
+          = error $ "CollocationPoints: toEnum: got unhandled number: " ++
+              show k
+instance Marshal CollocationPoints CInt where
+        marshal = return . fromIntegral . fromEnum
+instance WrapReturn CInt CollocationPoints where
+        wrapReturn = return . toEnum . fromIntegral
+
 -- EnumDecl: ControlSimulatorInput
 data ControlSimulatorInput = CONTROLSIMULATOR_NUM_IN
                            | CONTROLSIMULATOR_P
@@ -1705,21 +1723,10 @@
               | OT_DERIVATIVEGENERATOR
               | OT_DICTIONARY
               | OT_FUNCTION
-              | OT_IMPLICITFUNCTION
               | OT_INTEGER
               | OT_INTEGERVECTOR
-              | OT_INTEGRATOR
-              | OT_LINEARSOLVER
-              | OT_LPSOLVER
-              | OT_NLPSOLVER
-              | OT_QCQPSOLVER
-              | OT_QPSOLVER
               | OT_REAL
               | OT_REALVECTOR
-              | OT_SDPSOLVER
-              | OT_SDQPSOLVER
-              | OT_SOCPSOLVER
-              | OT_STABILIZEDQPSOLVER
               | OT_STRING
               | OT_STRINGVECTOR
               | OT_UNKNOWN
@@ -1728,54 +1735,32 @@
 instance Enum Opt_type where
         fromEnum (OT_BOOLEAN) = 0
         fromEnum (OT_BOOLVECTOR) = 5
-        fromEnum (OT_CALLBACK) = 22
-        fromEnum (OT_DERIVATIVEGENERATOR) = 20
+        fromEnum (OT_CALLBACK) = 11
+        fromEnum (OT_DERIVATIVEGENERATOR) = 9
         fromEnum (OT_DICTIONARY) = 8
-        fromEnum (OT_FUNCTION) = 21
-        fromEnum (OT_IMPLICITFUNCTION) = 19
+        fromEnum (OT_FUNCTION) = 10
         fromEnum (OT_INTEGER) = 1
         fromEnum (OT_INTEGERVECTOR) = 4
-        fromEnum (OT_INTEGRATOR) = 12
-        fromEnum (OT_LINEARSOLVER) = 11
-        fromEnum (OT_LPSOLVER) = 10
-        fromEnum (OT_NLPSOLVER) = 9
-        fromEnum (OT_QCQPSOLVER) = 16
-        fromEnum (OT_QPSOLVER) = 13
         fromEnum (OT_REAL) = 2
         fromEnum (OT_REALVECTOR) = 6
-        fromEnum (OT_SDPSOLVER) = 17
-        fromEnum (OT_SDQPSOLVER) = 18
-        fromEnum (OT_SOCPSOLVER) = 15
-        fromEnum (OT_STABILIZEDQPSOLVER) = 14
         fromEnum (OT_STRING) = 3
         fromEnum (OT_STRINGVECTOR) = 7
-        fromEnum (OT_UNKNOWN) = 24
-        fromEnum (OT_VOIDPTR) = 23
+        fromEnum (OT_UNKNOWN) = 13
+        fromEnum (OT_VOIDPTR) = 12
         toEnum (0) = OT_BOOLEAN
         toEnum (5) = OT_BOOLVECTOR
-        toEnum (22) = OT_CALLBACK
-        toEnum (20) = OT_DERIVATIVEGENERATOR
+        toEnum (11) = OT_CALLBACK
+        toEnum (9) = OT_DERIVATIVEGENERATOR
         toEnum (8) = OT_DICTIONARY
-        toEnum (21) = OT_FUNCTION
-        toEnum (19) = OT_IMPLICITFUNCTION
+        toEnum (10) = OT_FUNCTION
         toEnum (1) = OT_INTEGER
         toEnum (4) = OT_INTEGERVECTOR
-        toEnum (12) = OT_INTEGRATOR
-        toEnum (11) = OT_LINEARSOLVER
-        toEnum (10) = OT_LPSOLVER
-        toEnum (9) = OT_NLPSOLVER
-        toEnum (16) = OT_QCQPSOLVER
-        toEnum (13) = OT_QPSOLVER
         toEnum (2) = OT_REAL
         toEnum (6) = OT_REALVECTOR
-        toEnum (17) = OT_SDPSOLVER
-        toEnum (18) = OT_SDQPSOLVER
-        toEnum (15) = OT_SOCPSOLVER
-        toEnum (14) = OT_STABILIZEDQPSOLVER
         toEnum (3) = OT_STRING
         toEnum (7) = OT_STRINGVECTOR
-        toEnum (24) = OT_UNKNOWN
-        toEnum (23) = OT_VOIDPTR
+        toEnum (13) = OT_UNKNOWN
+        toEnum (12) = OT_VOIDPTR
         toEnum k
           = error $ "Opt_type: toEnum: got unhandled number: " ++ show k
 instance Marshal Opt_type CInt where
diff --git a/Casadi/Core/Tools.hs b/Casadi/Core/Tools.hs
--- a/Casadi/Core/Tools.hs
+++ b/Casadi/Core/Tools.hs
@@ -39,6 +39,8 @@
          cofactor__0,
          cofactor__1,
          cofactor__2,
+         collocationPoints__0,
+         collocationPoints__1,
          complement,
          compress__0,
          compress__1,
@@ -157,6 +159,10 @@
          evalf__0,
          evalf__1,
          expand,
+         explicitRK__0,
+         explicitRK__1,
+         explicitRK__2,
+         explicitRK__3,
          extractShared__0,
          extractShared__1,
          extractShared__2,
@@ -275,6 +281,7 @@
          horzsplit__9,
          if_else__0,
          if_else__1,
+         implicitRK,
          inner_prod__0,
          inner_prod__1,
          inner_prod__2,
@@ -629,6 +636,8 @@
          pinv__0,
          pinv__1,
          pinv__2,
+         pinv__3,
+         pinv__4,
          poly_coeff,
          poly_roots,
          polyval__0,
@@ -970,6 +979,8 @@
          solve__1,
          solve__2,
          solve__3,
+         solve__4,
+         solve__5,
          sparse__0,
          sparse__1,
          sparse__2,
@@ -1866,6 +1877,51 @@
     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))
+{-|
+>Obtain collocation points of specific order and scheme.
+>
+>Parameters:
+>-----------
+>
+>scheme:  'radau' or 'legendre'
+-}
+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))
+{-|
+>Obtain collocation points of specific order and scheme.
+>
+>Parameters:
+>-----------
+>
+>scheme:  'radau' or 'legendre'
+-}
+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))
 {-|
@@ -3894,6 +3950,236 @@
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
+foreign import ccall unsafe "explicitRK__0" c_explicitRK__0
+  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f:  dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
+>+-----------+-------+----------------------------+
+>| Full name | Short |        Description         |
+>+===========+=======+============================+
+>| DAE_X     | x     | Differential state .       |
+>+-----------+-------+----------------------------+
+>| DAE_Z     | z     | Algebraic state .          |
+>+-----------+-------+----------------------------+
+>| DAE_P     | p     | Parameter .                |
+>+-----------+-------+----------------------------+
+>| DAE_T     | t     | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short |                Description                 |
+>+===========+=======+============================================+
+>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf:  Integration end time
+>
+>order:  Order of integration
+>
+>ne:  Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__0
+  :: Function -> IO Function
+explicitRK__0 x0 =
+  withMarshal x0 $ \x0' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_explicitRK__0 errStrPtrP x0'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "explicitRK__1" c_explicitRK__1
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f:  dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
+>+-----------+-------+----------------------------+
+>| Full name | Short |        Description         |
+>+===========+=======+============================+
+>| DAE_X     | x     | Differential state .       |
+>+-----------+-------+----------------------------+
+>| DAE_Z     | z     | Algebraic state .          |
+>+-----------+-------+----------------------------+
+>| DAE_P     | p     | Parameter .                |
+>+-----------+-------+----------------------------+
+>| DAE_T     | t     | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short |                Description                 |
+>+===========+=======+============================================+
+>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf:  Integration end time
+>
+>order:  Order of integration
+>
+>ne:  Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__1
+  :: Function -> MX -> IO Function
+explicitRK__1 x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_explicitRK__1 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "explicitRK__2" c_explicitRK__2
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f:  dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
+>+-----------+-------+----------------------------+
+>| Full name | Short |        Description         |
+>+===========+=======+============================+
+>| DAE_X     | x     | Differential state .       |
+>+-----------+-------+----------------------------+
+>| DAE_Z     | z     | Algebraic state .          |
+>+-----------+-------+----------------------------+
+>| DAE_P     | p     | Parameter .                |
+>+-----------+-------+----------------------------+
+>| DAE_T     | t     | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short |                Description                 |
+>+===========+=======+============================================+
+>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf:  Integration end time
+>
+>order:  Order of integration
+>
+>ne:  Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__2
+  :: Function -> MX -> Int -> IO Function
+explicitRK__2 x0 x1 x2 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_explicitRK__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 "explicitRK__3" c_explicitRK__3
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> CInt -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f:  dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
+>+-----------+-------+----------------------------+
+>| Full name | Short |        Description         |
+>+===========+=======+============================+
+>| DAE_X     | x     | Differential state .       |
+>+-----------+-------+----------------------------+
+>| DAE_Z     | z     | Algebraic state .          |
+>+-----------+-------+----------------------------+
+>| DAE_P     | p     | Parameter .                |
+>+-----------+-------+----------------------------+
+>| DAE_T     | t     | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short |                Description                 |
+>+===========+=======+============================================+
+>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf:  Integration end time
+>
+>order:  Order of integration
+>
+>ne:  Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__3
+  :: Function -> MX -> Int -> Int -> IO Function
+explicitRK__3 x0 x1 x2 x3 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
+  withMarshal x3 $ \x3' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_explicitRK__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 "extractShared__0" c_extractShared__0
   :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
 {-|
@@ -5979,6 +6265,65 @@
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
+foreign import ccall unsafe "implicitRK" c_implicitRK
+  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+{-|
+>Construct an implicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f:  dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
+>+-----------+-------+----------------------------+
+>| Full name | Short |        Description         |
+>+===========+=======+============================+
+>| DAE_X     | x     | Differential state .       |
+>+-----------+-------+----------------------------+
+>| DAE_Z     | z     | Algebraic state .          |
+>+-----------+-------+----------------------------+
+>| DAE_P     | p     | Parameter .                |
+>+-----------+-------+----------------------------+
+>| DAE_T     | t     | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short |                Description                 |
+>+===========+=======+============================================+
+>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf:  Integration end time
+>
+>order:  Order of integration
+>
+>scheme:  Collocation scheme, as excepted by collocationPoints function.
+>
+>ne:  Number of times the RK primitive is repeated over the integration
+>interval
+-}
+implicitRK
+  :: Function -> String -> IO Function
+implicitRK x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_implicitRK errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
 foreign import ccall unsafe "inner_prod__0" c_inner_prod__0
   :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
 {-|
@@ -12172,27 +12517,28 @@
 
 
 foreign import ccall unsafe "pinv__0" c_pinv__0
-  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
 {-|
 >Computes the Moore-Penrose pseudo-inverse.
 >
->If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
->matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
+>If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
 -}
 pinv__0
-  :: SX -> IO SX
-pinv__0 x0 =
+  :: MX -> String -> IO MX
+pinv__0 x0 x1 =
   withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
   do
     errStrPtrP <- new nullPtr
-    ret <- c_pinv__0 errStrPtrP x0'
+    ret <- c_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 "pinv__1" c_pinv__1
-  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
 {-|
 >Computes the Moore-Penrose pseudo-inverse.
 >
@@ -12200,7 +12546,7 @@
 >matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
 -}
 pinv__1
-  :: DMatrix -> IO DMatrix
+  :: SX -> IO SX
 pinv__1 x0 =
   withMarshal x0 $ \x0' ->
   do
@@ -12212,7 +12558,7 @@
 
 
 foreign import ccall unsafe "pinv__2" c_pinv__2
-  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
 {-|
 >Computes the Moore-Penrose pseudo-inverse.
 >
@@ -12220,7 +12566,7 @@
 >matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
 -}
 pinv__2
-  :: IMatrix -> IO IMatrix
+  :: DMatrix -> IO DMatrix
 pinv__2 x0 =
   withMarshal x0 $ \x0' ->
   do
@@ -12231,6 +12577,47 @@
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
+foreign import ccall unsafe "pinv__3" c_pinv__3
+  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
+-}
+pinv__3
+  :: IMatrix -> IO IMatrix
+pinv__3 x0 =
+  withMarshal x0 $ \x0' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_pinv__3 errStrPtrP x0'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "pinv__4" c_pinv__4
+  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
+-}
+pinv__4
+  :: DMatrix -> String -> IO DMatrix
+pinv__4 x0 x1 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_pinv__4 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
 foreign import ccall unsafe "poly_coeff" c_poly_coeff
   :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
 {-|
@@ -18276,6 +18663,25 @@
 
 
 foreign import ccall unsafe "solve__1" c_solve__1
+  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+{-|
+>Solve a system of equations: A*x = b.
+-}
+solve__1
+  :: MX -> MX -> String -> IO MX
+solve__1 x0 x1 x2 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_solve__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 "solve__2" c_solve__2
   :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
 {-|
 >Solve a system of equations: A*x = b The solve routine works similar to
@@ -18301,20 +18707,20 @@
 >An improvement would be to solve block-by-block if there are multiple BLT
 >blocks.
 -}
-solve__1
+solve__2
   :: SX -> SX -> IO SX
-solve__1 x0 x1 =
+solve__2 x0 x1 =
   withMarshal x0 $ \x0' ->
   withMarshal x1 $ \x1' ->
   do
     errStrPtrP <- new nullPtr
-    ret <- c_solve__1 errStrPtrP x0' x1'
+    ret <- c_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 "solve__2" c_solve__2
+foreign import ccall unsafe "solve__3" c_solve__3
   :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
 {-|
 >Solve a system of equations: A*x = b The solve routine works similar to
@@ -18340,20 +18746,20 @@
 >An improvement would be to solve block-by-block if there are multiple BLT
 >blocks.
 -}
-solve__2
+solve__3
   :: DMatrix -> DMatrix -> IO DMatrix
-solve__2 x0 x1 =
+solve__3 x0 x1 =
   withMarshal x0 $ \x0' ->
   withMarshal x1 $ \x1' ->
   do
     errStrPtrP <- new nullPtr
-    ret <- c_solve__2 errStrPtrP x0' x1'
+    ret <- c_solve__3 errStrPtrP x0' x1'
     errStrPtr <- peek errStrPtrP
     free errStrPtrP
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
 
 
-foreign import ccall unsafe "solve__3" c_solve__3
+foreign import ccall unsafe "solve__4" c_solve__4
   :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
 {-|
 >Solve a system of equations: A*x = b The solve routine works similar to
@@ -18379,14 +18785,33 @@
 >An improvement would be to solve block-by-block if there are multiple BLT
 >blocks.
 -}
-solve__3
+solve__4
   :: IMatrix -> IMatrix -> IO IMatrix
-solve__3 x0 x1 =
+solve__4 x0 x1 =
   withMarshal x0 $ \x0' ->
   withMarshal x1 $ \x1' ->
   do
     errStrPtrP <- new nullPtr
-    ret <- c_solve__3 errStrPtrP x0' x1'
+    ret <- c_solve__4 errStrPtrP x0' x1'
+    errStrPtr <- peek errStrPtrP
+    free errStrPtrP
+    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "solve__5" c_solve__5
+  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')
+{-|
+>Solve a system of equations: A*x = b.
+-}
+solve__5
+  :: DMatrix -> DMatrix -> String -> IO DMatrix
+solve__5 x0 x1 x2 =
+  withMarshal x0 $ \x0' ->
+  withMarshal x1 $ \x1' ->
+  withMarshal x2 $ \x2' ->
+  do
+    errStrPtrP <- new nullPtr
+    ret <- c_solve__5 errStrPtrP x0' x1' x2'
     errStrPtr <- peek errStrPtrP
     free errStrPtrP
     if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
diff --git a/casadi-bindings-core.cabal b/casadi-bindings-core.cabal
--- a/casadi-bindings-core.cabal
+++ b/casadi-bindings-core.cabal
@@ -1,5 +1,5 @@
 name:                casadi-bindings-core
-version:             1.9.0.3
+version:             1.9.0.4
 license:             LGPL-3
 license-file:        LICENSE
 category:            Numerical, Math
@@ -76,5 +76,5 @@
                     Casadi.Core.Classes.Slice
                     Casadi.Core.Classes.Sparsity
                     Casadi.Core.Classes.StabilizedQPSolver
-                    Casadi.Core.Classes.SymbolicQR
+                    Casadi.Core.Classes.SymbolicNLP
                     Casadi.Core.Classes.IOInterfaceFunction
diff --git a/cbits/autogen/core_classes.cpp b/cbits/autogen/core_classes.cpp
# file too large to diff: cbits/autogen/core_classes.cpp
diff --git a/cbits/autogen/core_functions.cpp b/cbits/autogen/core_functions.cpp
--- a/cbits/autogen/core_functions.cpp
+++ b/cbits/autogen/core_functions.cpp
@@ -26,7 +26,6 @@
 #include "casadi/core/function/socp_solver.hpp"
 #include "casadi/core/function/stabilized_qp_solver.hpp"
 #include "casadi/core/function/sx_function.hpp"
-#include "casadi/core/function/symbolic_qr.hpp"
 #include "casadi/core/functor.hpp"
 #include "casadi/core/generic_type.hpp"
 #include "casadi/core/matrix/generic_expression.hpp"
@@ -36,6 +35,8 @@
 #include "casadi/core/matrix/slice.hpp"
 #include "casadi/core/matrix/sparsity.hpp"
 #include "casadi/core/matrix/sparsity_tools.hpp"
+#include "casadi/core/misc/integration_tools.hpp"
+#include "casadi/core/misc/symbolic_nlp.hpp"
 #include "casadi/core/mx/mx.hpp"
 #include "casadi/core/mx/mx_tools.hpp"
 #include "casadi/core/options_functionality.hpp"
@@ -1010,6 +1011,57 @@
 }
 
 
+// ================== function "casadi::collocationPoints" ===============
+// cppName: "casadi::collocationPoints"
+// cWrapperName: "collocationPoints__0"
+// protoArgs: "(std::string ** err_msg, int x0)"
+// params: [CInt]
+// retType: StdVec CDouble
+// args: "(x0_)"
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >* collocationPoints__0(std::string ** err_msg, int x0)"
+// call: "casadi::collocationPoints(x0_)"
+extern "C"
+    std::vector< double >* collocationPoints__0(std::string ** err_msg, int x0);
+std::vector< double >* collocationPoints__0(std::string ** err_msg, int x0){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+
+        std::vector< double > ret = casadi::collocationPoints(x0_);
+        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== function "casadi::collocationPoints" ===============
+// cppName: "casadi::collocationPoints"
+// cWrapperName: "collocationPoints__1"
+// protoArgs: "(std::string ** err_msg, int x0, std::string* x1)"
+// params: [CInt,Ref (Const StdString)]
+// retType: StdVec CDouble
+// args: "(x0_, x1_)"
+// cWrapperRetType: "std::vector< double >*"
+// proto: "std::vector< double >* collocationPoints__1(std::string ** err_msg, int x0, std::string* x1)"
+// call: "casadi::collocationPoints(x0_, x1_)"
+extern "C"
+    std::vector< double >* collocationPoints__1(std::string ** err_msg, int x0, std::string* x1);
+std::vector< double >* collocationPoints__1(std::string ** err_msg, int x0, std::string* x1){
+    try {
+        int x0_ = Marshaling<int,int>::marshal(x0);
+        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
+
+        std::vector< double > ret = casadi::collocationPoints(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;
+    }
+}
+
+
 // ================== function "casadi::complement" ===============
 // cppName: "casadi::complement"
 // cWrapperName: "complement"
@@ -4192,6 +4244,112 @@
 }
 
 
+// ================== function "casadi::explicitRK" ===============
+// cppName: "casadi::explicitRK"
+// cWrapperName: "explicitRK__0"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
+// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function"))]
+// retType: UserType (Namespace ["casadi"]) (Name "Function")
+// args: "(x0_)"
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function* explicitRK__0(std::string ** err_msg, casadi::Function* x0)"
+// call: "casadi::explicitRK(x0_)"
+extern "C"
+    casadi::Function* explicitRK__0(std::string ** err_msg, casadi::Function* x0);
+casadi::Function* explicitRK__0(std::string ** err_msg, casadi::Function* x0){
+    try {
+        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
+
+        casadi::Function ret = casadi::explicitRK(x0_);
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== function "casadi::explicitRK" ===============
+// cppName: "casadi::explicitRK"
+// cWrapperName: "explicitRK__1"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1)"
+// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function")),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
+// retType: UserType (Namespace ["casadi"]) (Name "Function")
+// args: "(x0_, x1_)"
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function* explicitRK__1(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1)"
+// call: "casadi::explicitRK(x0_, x1_)"
+extern "C"
+    casadi::Function* explicitRK__1(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1);
+casadi::Function* explicitRK__1(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1){
+    try {
+        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
+        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
+
+        casadi::Function ret = casadi::explicitRK(x0_, x1_);
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== function "casadi::explicitRK" ===============
+// cppName: "casadi::explicitRK"
+// cWrapperName: "explicitRK__2"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2)"
+// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function")),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
+// retType: UserType (Namespace ["casadi"]) (Name "Function")
+// args: "(x0_, x1_, x2_)"
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function* explicitRK__2(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2)"
+// call: "casadi::explicitRK(x0_, x1_, x2_)"
+extern "C"
+    casadi::Function* explicitRK__2(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2);
+casadi::Function* explicitRK__2(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2){
+    try {
+        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
+        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+
+        casadi::Function ret = casadi::explicitRK(x0_, x1_, x2_);
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== function "casadi::explicitRK" ===============
+// cppName: "casadi::explicitRK"
+// cWrapperName: "explicitRK__3"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2, int x3)"
+// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function")),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,CInt]
+// retType: UserType (Namespace ["casadi"]) (Name "Function")
+// args: "(x0_, x1_, x2_, x3_)"
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function* explicitRK__3(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2, int x3)"
+// call: "casadi::explicitRK(x0_, x1_, x2_, x3_)"
+extern "C"
+    casadi::Function* explicitRK__3(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2, int x3);
+casadi::Function* explicitRK__3(std::string ** err_msg, casadi::Function* x0, casadi::MX* x1, int x2, int x3){
+    try {
+        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
+        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
+        int x2_ = Marshaling<int,int>::marshal(x2);
+        int x3_ = Marshaling<int,int>::marshal(x3);
+
+        casadi::Function ret = casadi::explicitRK(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;
+    }
+}
+
+
 // ================== function "casadi::extractShared" ===============
 // cppName: "casadi::extractShared"
 // cWrapperName: "extractShared__0"
@@ -7320,6 +7478,32 @@
 }
 
 
+// ================== function "casadi::implicitRK" ===============
+// cppName: "casadi::implicitRK"
+// cWrapperName: "implicitRK"
+// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// params: [Ref (UserType (Namespace ["casadi"]) (Name "Function")),Ref (Const StdString)]
+// retType: UserType (Namespace ["casadi"]) (Name "Function")
+// args: "(x0_, x1_)"
+// cWrapperRetType: "casadi::Function*"
+// proto: "casadi::Function* implicitRK(std::string ** err_msg, casadi::Function* x0, std::string* x1)"
+// call: "casadi::implicitRK(x0_, x1_)"
+extern "C"
+    casadi::Function* implicitRK(std::string ** err_msg, casadi::Function* x0, std::string* x1);
+casadi::Function* implicitRK(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::Function ret = casadi::implicitRK(x0_, x1_);
+        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
 // ================== function "casadi::inner_prod" ===============
 // cppName: "casadi::inner_prod"
 // cWrapperName: "inner_prod__0"
@@ -16926,16 +17110,42 @@
 // ================== function "casadi::pinv" ===============
 // cppName: "casadi::pinv"
 // cWrapperName: "pinv__0"
+// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::string* x1)"
+// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
+// retType: UserType (Namespace ["casadi"]) (Name "MX")
+// args: "(x0_, x1_)"
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX* pinv__0(std::string ** err_msg, casadi::MX* x0, std::string* x1)"
+// call: "casadi::pinv(x0_, x1_)"
+extern "C"
+    casadi::MX* pinv__0(std::string ** err_msg, casadi::MX* x0, std::string* x1);
+casadi::MX* pinv__0(std::string ** err_msg, 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 = casadi::pinv(x0_, x1_);
+        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== function "casadi::pinv" ===============
+// cppName: "casadi::pinv"
+// cWrapperName: "pinv__1"
 // protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
 // params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
 // retType: UserType (Namespace ["casadi"]) (Name "SX")
 // args: "(x0_)"
 // cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX* pinv__0(std::string ** err_msg, casadi::SX* x0)"
+// proto: "casadi::SX* pinv__1(std::string ** err_msg, casadi::SX* x0)"
 // call: "casadi::pinv(x0_)"
 extern "C"
-    casadi::SX* pinv__0(std::string ** err_msg, casadi::SX* x0);
-casadi::SX* pinv__0(std::string ** err_msg, casadi::SX* x0){
+    casadi::SX* pinv__1(std::string ** err_msg, casadi::SX* x0);
+casadi::SX* pinv__1(std::string ** err_msg, casadi::SX* x0){
     try {
         casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
 
@@ -16950,17 +17160,17 @@
 
 // ================== function "casadi::pinv" ===============
 // cppName: "casadi::pinv"
-// cWrapperName: "pinv__1"
+// cWrapperName: "pinv__2"
 // protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
 // params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
 // retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
 // args: "(x0_)"
 // cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix* pinv__1(std::string ** err_msg, casadi::DMatrix* x0)"
+// proto: "casadi::DMatrix* pinv__2(std::string ** err_msg, casadi::DMatrix* x0)"
 // call: "casadi::pinv(x0_)"
 extern "C"
-    casadi::DMatrix* pinv__1(std::string ** err_msg, casadi::DMatrix* x0);
-casadi::DMatrix* pinv__1(std::string ** err_msg, casadi::DMatrix* x0){
+    casadi::DMatrix* pinv__2(std::string ** err_msg, casadi::DMatrix* x0);
+casadi::DMatrix* pinv__2(std::string ** err_msg, casadi::DMatrix* x0){
     try {
         casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
 
@@ -16975,17 +17185,17 @@
 
 // ================== function "casadi::pinv" ===============
 // cppName: "casadi::pinv"
-// cWrapperName: "pinv__2"
+// cWrapperName: "pinv__3"
 // protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
 // params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
 // retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
 // args: "(x0_)"
 // cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix* pinv__2(std::string ** err_msg, casadi::IMatrix* x0)"
+// proto: "casadi::IMatrix* pinv__3(std::string ** err_msg, casadi::IMatrix* x0)"
 // call: "casadi::pinv(x0_)"
 extern "C"
-    casadi::IMatrix* pinv__2(std::string ** err_msg, casadi::IMatrix* x0);
-casadi::IMatrix* pinv__2(std::string ** err_msg, casadi::IMatrix* x0){
+    casadi::IMatrix* pinv__3(std::string ** err_msg, casadi::IMatrix* x0);
+casadi::IMatrix* pinv__3(std::string ** err_msg, casadi::IMatrix* x0){
     try {
         casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
 
@@ -16998,6 +17208,32 @@
 }
 
 
+// ================== function "casadi::pinv" ===============
+// cppName: "casadi::pinv"
+// cWrapperName: "pinv__4"
+// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::string* x1)"
+// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
+// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
+// args: "(x0_, x1_)"
+// cWrapperRetType: "casadi::DMatrix*"
+// proto: "casadi::DMatrix* pinv__4(std::string ** err_msg, casadi::DMatrix* x0, std::string* x1)"
+// call: "casadi::pinv(x0_, x1_)"
+extern "C"
+    casadi::DMatrix* pinv__4(std::string ** err_msg, casadi::DMatrix* x0, std::string* x1);
+casadi::DMatrix* pinv__4(std::string ** err_msg, 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);
+
+        casadi::DMatrix ret = casadi::pinv(x0_, x1_);
+        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
 // ================== function "casadi::poly_coeff" ===============
 // cppName: "casadi::poly_coeff"
 // cWrapperName: "poly_coeff"
@@ -26645,16 +26881,43 @@
 // ================== function "casadi::solve" ===============
 // cppName: "casadi::solve"
 // cWrapperName: "solve__1"
+// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, std::string* x2)"
+// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
+// retType: UserType (Namespace ["casadi"]) (Name "MX")
+// args: "(x0_, x1_, x2_)"
+// cWrapperRetType: "casadi::MX*"
+// proto: "casadi::MX* solve__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, std::string* x2)"
+// call: "casadi::solve(x0_, x1_, x2_)"
+extern "C"
+    casadi::MX* solve__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, std::string* x2);
+casadi::MX* solve__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, std::string* x2){
+    try {
+        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
+        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
+        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
+
+        casadi::MX ret = casadi::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;
+    }
+}
+
+
+// ================== function "casadi::solve" ===============
+// cppName: "casadi::solve"
+// cWrapperName: "solve__2"
 // protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
 // params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
 // retType: UserType (Namespace ["casadi"]) (Name "SX")
 // args: "(x0_, x1_)"
 // cWrapperRetType: "casadi::SX*"
-// proto: "casadi::SX* solve__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
+// proto: "casadi::SX* solve__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
 // call: "casadi::solve(x0_, x1_)"
 extern "C"
-    casadi::SX* solve__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
-casadi::SX* solve__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
+    casadi::SX* solve__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
+casadi::SX* solve__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
     try {
         casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
         casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
@@ -26670,17 +26933,17 @@
 
 // ================== function "casadi::solve" ===============
 // cppName: "casadi::solve"
-// cWrapperName: "solve__2"
+// cWrapperName: "solve__3"
 // protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
 // params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
 // retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
 // args: "(x0_, x1_)"
 // cWrapperRetType: "casadi::DMatrix*"
-// proto: "casadi::DMatrix* solve__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
+// proto: "casadi::DMatrix* solve__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
 // call: "casadi::solve(x0_, x1_)"
 extern "C"
-    casadi::DMatrix* solve__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
-casadi::DMatrix* solve__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
+    casadi::DMatrix* solve__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
+casadi::DMatrix* solve__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
     try {
         casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
         casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);
@@ -26696,23 +26959,50 @@
 
 // ================== function "casadi::solve" ===============
 // cppName: "casadi::solve"
-// cWrapperName: "solve__3"
+// cWrapperName: "solve__4"
 // protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
 // params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
 // retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
 // args: "(x0_, x1_)"
 // cWrapperRetType: "casadi::IMatrix*"
-// proto: "casadi::IMatrix* solve__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
+// proto: "casadi::IMatrix* solve__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
 // call: "casadi::solve(x0_, x1_)"
 extern "C"
-    casadi::IMatrix* solve__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
-casadi::IMatrix* solve__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
+    casadi::IMatrix* solve__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
+casadi::IMatrix* solve__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
     try {
         casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
         casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
 
         casadi::IMatrix ret = casadi::solve(x0_, x1_);
         return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
+    } catch (std::exception& ex) {
+         *err_msg = new std::string(ex.what());
+         return 0;
+    }
+}
+
+
+// ================== function "casadi::solve" ===============
+// cppName: "casadi::solve"
+// cWrapperName: "solve__5"
+// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, std::string* x2)"
+// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
+// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
+// args: "(x0_, x1_, x2_)"
+// cWrapperRetType: "casadi::DMatrix*"
+// proto: "casadi::DMatrix* solve__5(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, std::string* x2)"
+// call: "casadi::solve(x0_, x1_, x2_)"
+extern "C"
+    casadi::DMatrix* solve__5(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, std::string* x2);
+casadi::DMatrix* solve__5(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, std::string* x2){
+    try {
+        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
+        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);
+        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
+
+        casadi::DMatrix ret = casadi::solve(x0_, x1_, x2_);
+        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
     } catch (std::exception& ex) {
          *err_msg = new std::string(ex.what());
          return 0;