casadi-bindings-core-2.2.0.0: Casadi/Core/Classes/Function.hs

{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# Language ForeignFunctionInterface #-}
{-# Language FlexibleInstances #-}
{-# Language MultiParamTypeClasses #-}

module Casadi.Core.Classes.Function
       (
         Function,
         FunctionClass(..),
         function,
         function_addMonitor,
         function_callDerivative__0,
         function_callDerivative__1,
         function_callDerivative__2,
         function_callDerivative__3,
         function_callDerivative__4,
         function_callDerivative__5,
         function_callDerivative__6,
         function_callDerivative__7,
         function_callDerivative__8,
         function_callParallel,
         function_call__0,
         function_call__1,
         function_call__2,
         function_call__3,
         function_call__4,
         function_call__5,
         function_call__6,
         function_call__7,
         function_call__8,
         function_checkInputs,
         function_derivative,
         function_evaluate,
         function_fullJacobian,
         function_generateCode__0,
         function_generateCode__1,
         function_generateCode__2,
         function_generateCode__3,
         function_getInputScheme,
         function_getNumInputElements,
         function_getNumInputNonzeros,
         function_getNumOutputElements,
         function_getNumOutputNonzeros,
         function_getOutputScheme,
         function_getSanitizedName,
         function_getStat,
         function_gradient__0,
         function_gradient__1,
         function_gradient__2,
         function_gradient__3,
         function_gradient__4,
         function_gradient__5,
         function_gradient__6,
         function_hessian__0,
         function_hessian__1,
         function_hessian__2,
         function_hessian__3,
         function_hessian__4,
         function_hessian__5,
         function_hessian__6,
         function_inputScheme__0,
         function_inputScheme__1,
         function_jacSparsity__0,
         function_jacSparsity__1,
         function_jacSparsity__10,
         function_jacSparsity__11,
         function_jacSparsity__12,
         function_jacSparsity__13,
         function_jacSparsity__14,
         function_jacSparsity__2,
         function_jacSparsity__3,
         function_jacSparsity__4,
         function_jacSparsity__5,
         function_jacSparsity__6,
         function_jacSparsity__7,
         function_jacSparsity__8,
         function_jacSparsity__9,
         function_jacobian__0,
         function_jacobian__1,
         function_jacobian__10,
         function_jacobian__11,
         function_jacobian__12,
         function_jacobian__13,
         function_jacobian__14,
         function_jacobian__2,
         function_jacobian__3,
         function_jacobian__4,
         function_jacobian__5,
         function_jacobian__6,
         function_jacobian__7,
         function_jacobian__8,
         function_jacobian__9,
         function_outputScheme__0,
         function_outputScheme__1,
         function_removeMonitor,
         function_setDerivative,
         function_setFullJacobian,
         function_setInputScheme,
         function_setJacSparsity__0,
         function_setJacSparsity__1,
         function_setJacSparsity__2,
         function_setJacSparsity__3,
         function_setJacSparsity__4,
         function_setJacSparsity__5,
         function_setJacSparsity__6,
         function_setJacSparsity__7,
         function_setJacobian__0,
         function_setJacobian__1,
         function_setJacobian__2,
         function_setJacobian__3,
         function_setOutputScheme,
         function_spCanEvaluate,
         function_spEvaluate,
         function_spInit,
         function_symbolicInput,
         function_symbolicInputSX,
         function_tangent__0,
         function_tangent__1,
         function_tangent__2,
         function_tangent__3,
         function_tangent__4,
         function_tangent__5,
         function_tangent__6,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Marshal ( new, free )
import Foreign.Storable ( peek )
import Foreign.Ptr ( Ptr, nullPtr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Internal.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
-- direct wrapper
foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR
  :: Ptr (Ptr StdString) -> IO (Ptr Function')
casadi__Function__CONSTRUCTOR
  :: IO Function
casadi__Function__CONSTRUCTOR  =

  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__CONSTRUCTOR errStrPtrP 
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function :: IO Function
function = casadi__Function__CONSTRUCTOR


-- direct wrapper
foreign import ccall unsafe "casadi__Function__addMonitor" c_casadi__Function__addMonitor
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
casadi__Function__addMonitor
  :: Function -> String -> IO ()
casadi__Function__addMonitor x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__addMonitor errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_addMonitor :: FunctionClass a => a -> String -> IO ()
function_addMonitor x = casadi__Function__addMonitor (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__0" c_casadi__Function__call__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
casadi__Function__call__0
  :: Function -> Vector MX -> IO (Vector MX)
casadi__Function__call__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
function_call__0 x = casadi__Function__call__0 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__1" c_casadi__Function__call__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec (Ptr MX')))
casadi__Function__call__1
  :: Function -> Vector MX -> Bool -> IO (Vector MX)
casadi__Function__call__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__1 :: FunctionClass a => a -> Vector MX -> Bool -> IO (Vector MX)
function_call__1 x = casadi__Function__call__1 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__2" c_casadi__Function__call__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
casadi__Function__call__2
  :: Function -> Vector MX -> Bool -> Bool -> IO (Vector MX)
casadi__Function__call__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__2 :: FunctionClass a => a -> Vector MX -> Bool -> Bool -> IO (Vector MX)
function_call__2 x = casadi__Function__call__2 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__3" c_casadi__Function__call__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
casadi__Function__call__3
  :: Function -> Vector SX -> IO (Vector SX)
casadi__Function__call__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__3 :: FunctionClass a => a -> Vector SX -> IO (Vector SX)
function_call__3 x = casadi__Function__call__3 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__4" c_casadi__Function__call__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec (Ptr SX')))
casadi__Function__call__4
  :: Function -> Vector SX -> Bool -> IO (Vector SX)
casadi__Function__call__4 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__4 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__4 :: FunctionClass a => a -> Vector SX -> Bool -> IO (Vector SX)
function_call__4 x = casadi__Function__call__4 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__5" c_casadi__Function__call__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
casadi__Function__call__5
  :: Function -> Vector SX -> Bool -> Bool -> IO (Vector SX)
casadi__Function__call__5 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__5 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__5 :: FunctionClass a => a -> Vector SX -> Bool -> Bool -> IO (Vector SX)
function_call__5 x = casadi__Function__call__5 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__6" c_casadi__Function__call__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix')))
casadi__Function__call__6
  :: Function -> Vector DMatrix -> IO (Vector DMatrix)
casadi__Function__call__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__6 :: FunctionClass a => a -> Vector DMatrix -> IO (Vector DMatrix)
function_call__6 x = casadi__Function__call__6 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__7" c_casadi__Function__call__7
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
casadi__Function__call__7
  :: Function -> Vector DMatrix -> Bool -> IO (Vector DMatrix)
casadi__Function__call__7 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__7 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__7 :: FunctionClass a => a -> Vector DMatrix -> Bool -> IO (Vector DMatrix)
function_call__7 x = casadi__Function__call__7 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__call__8" c_casadi__Function__call__8
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
casadi__Function__call__8
  :: Function -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix)
casadi__Function__call__8 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__call__8 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_call__8 :: FunctionClass a => a -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix)
function_call__8 x = casadi__Function__call__8 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__0" c_casadi__Function__callDerivative__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO ()
casadi__Function__callDerivative__0
  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
casadi__Function__callDerivative__0 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
function_callDerivative__0 x = casadi__Function__callDerivative__0 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__1" c_casadi__Function__callDerivative__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO ()
casadi__Function__callDerivative__1
  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
casadi__Function__callDerivative__1 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO ()
function_callDerivative__1 x = casadi__Function__callDerivative__1 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__2" c_casadi__Function__callDerivative__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO ()
casadi__Function__callDerivative__2
  :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
casadi__Function__callDerivative__2 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO ()
function_callDerivative__2 x = casadi__Function__callDerivative__2 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__3" c_casadi__Function__callDerivative__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO ()
casadi__Function__callDerivative__3
  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
casadi__Function__callDerivative__3 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__3 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
function_callDerivative__3 x = casadi__Function__callDerivative__3 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__4" c_casadi__Function__callDerivative__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO ()
casadi__Function__callDerivative__4
  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
casadi__Function__callDerivative__4 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__4 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO ()
function_callDerivative__4 x = casadi__Function__callDerivative__4 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__5" c_casadi__Function__callDerivative__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO ()
casadi__Function__callDerivative__5
  :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
casadi__Function__callDerivative__5 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO ()
function_callDerivative__5 x = casadi__Function__callDerivative__5 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__6" c_casadi__Function__callDerivative__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO ()
casadi__Function__callDerivative__6
  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
casadi__Function__callDerivative__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
function_callDerivative__6 x = casadi__Function__callDerivative__6 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__7" c_casadi__Function__callDerivative__7
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO ()
casadi__Function__callDerivative__7
  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
casadi__Function__callDerivative__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO ()
function_callDerivative__7 x = casadi__Function__callDerivative__7 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callDerivative__8" c_casadi__Function__callDerivative__8
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO ()
casadi__Function__callDerivative__8
  :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
casadi__Function__callDerivative__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callDerivative__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callDerivative__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO ()
function_callDerivative__8 x = casadi__Function__callDerivative__8 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__callParallel" c_casadi__Function__callParallel
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
casadi__Function__callParallel
  :: Function -> Vector (Vector MX) -> IO (Vector (Vector MX))
casadi__Function__callParallel x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__callParallel errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_callParallel :: FunctionClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX))
function_callParallel x = casadi__Function__callParallel (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__checkInputs" c_casadi__Function__checkInputs
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
casadi__Function__checkInputs
  :: Function -> IO ()
casadi__Function__checkInputs x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__checkInputs errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_checkInputs :: FunctionClass a => a -> IO ()
function_checkInputs x = casadi__Function__checkInputs (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__derivative" c_casadi__Function__derivative
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__derivative
  :: Function -> Int -> Int -> IO Function
casadi__Function__derivative x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__derivative errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_derivative :: FunctionClass a => a -> Int -> Int -> IO Function
function_derivative x = casadi__Function__derivative (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__evaluate" c_casadi__Function__evaluate
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO ()
casadi__Function__evaluate
  :: Function -> IO ()
casadi__Function__evaluate x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__evaluate errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_evaluate :: FunctionClass a => a -> IO ()
function_evaluate x = casadi__Function__evaluate (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__fullJacobian" c_casadi__Function__fullJacobian
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
casadi__Function__fullJacobian
  :: Function -> IO Function
casadi__Function__fullJacobian x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__fullJacobian errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_fullJacobian :: FunctionClass a => a -> IO Function
function_fullJacobian x = casadi__Function__fullJacobian (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__generateCode__0" c_casadi__Function__generateCode__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
casadi__Function__generateCode__0
  :: Function -> String -> IO ()
casadi__Function__generateCode__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__generateCode__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_generateCode__0 :: FunctionClass a => a -> String -> IO ()
function_generateCode__0 x = casadi__Function__generateCode__0 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__generateCode__1" c_casadi__Function__generateCode__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO ()
casadi__Function__generateCode__1
  :: Function -> String -> Bool -> IO ()
casadi__Function__generateCode__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__generateCode__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_generateCode__1 :: FunctionClass a => a -> String -> Bool -> IO ()
function_generateCode__1 x = casadi__Function__generateCode__1 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__generateCode__2" c_casadi__Function__generateCode__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
casadi__Function__generateCode__2
  :: Function -> String -> IO ()
casadi__Function__generateCode__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__generateCode__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_generateCode__2 :: FunctionClass a => a -> String -> IO ()
function_generateCode__2 x = casadi__Function__generateCode__2 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__generateCode__3" c_casadi__Function__generateCode__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO ()
casadi__Function__generateCode__3
  :: Function -> String -> Bool -> IO ()
casadi__Function__generateCode__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__generateCode__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_generateCode__3 :: FunctionClass a => a -> String -> Bool -> IO ()
function_generateCode__3 x = casadi__Function__generateCode__3 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getInputScheme" c_casadi__Function__getInputScheme
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme')
casadi__Function__getInputScheme
  :: Function -> IO IOScheme
casadi__Function__getInputScheme x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getInputScheme errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getInputScheme :: FunctionClass a => a -> IO IOScheme
function_getInputScheme x = casadi__Function__getInputScheme (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getNumInputElements" c_casadi__Function__getNumInputElements
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
casadi__Function__getNumInputElements
  :: Function -> IO Int
casadi__Function__getNumInputElements x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getNumInputElements errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getNumInputElements :: FunctionClass a => a -> IO Int
function_getNumInputElements x = casadi__Function__getNumInputElements (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getNumInputNonzeros" c_casadi__Function__getNumInputNonzeros
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
casadi__Function__getNumInputNonzeros
  :: Function -> IO Int
casadi__Function__getNumInputNonzeros x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getNumInputNonzeros errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getNumInputNonzeros :: FunctionClass a => a -> IO Int
function_getNumInputNonzeros x = casadi__Function__getNumInputNonzeros (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getNumOutputElements" c_casadi__Function__getNumOutputElements
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
casadi__Function__getNumOutputElements
  :: Function -> IO Int
casadi__Function__getNumOutputElements x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getNumOutputElements errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getNumOutputElements :: FunctionClass a => a -> IO Int
function_getNumOutputElements x = casadi__Function__getNumOutputElements (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getNumOutputNonzeros" c_casadi__Function__getNumOutputNonzeros
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt
casadi__Function__getNumOutputNonzeros
  :: Function -> IO Int
casadi__Function__getNumOutputNonzeros x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getNumOutputNonzeros errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getNumOutputNonzeros :: FunctionClass a => a -> IO Int
function_getNumOutputNonzeros x = casadi__Function__getNumOutputNonzeros (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getOutputScheme" c_casadi__Function__getOutputScheme
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme')
casadi__Function__getOutputScheme
  :: Function -> IO IOScheme
casadi__Function__getOutputScheme x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getOutputScheme errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getOutputScheme :: FunctionClass a => a -> IO IOScheme
function_getOutputScheme x = casadi__Function__getOutputScheme (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getSanitizedName" c_casadi__Function__getSanitizedName
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString)
casadi__Function__getSanitizedName
  :: Function -> IO String
casadi__Function__getSanitizedName x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getSanitizedName errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getSanitizedName :: FunctionClass a => a -> IO String
function_getSanitizedName x = casadi__Function__getSanitizedName (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__getStat" c_casadi__Function__getStat
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr GenericType')
casadi__Function__getStat
  :: Function -> String -> IO GenericType
casadi__Function__getStat x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__getStat errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_getStat :: FunctionClass a => a -> String -> IO GenericType
function_getStat x = casadi__Function__getStat (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__0" c_casadi__Function__gradient__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
casadi__Function__gradient__0
  :: Function -> String -> String -> IO Function
casadi__Function__gradient__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__0 :: FunctionClass a => a -> String -> String -> IO Function
function_gradient__0 x = casadi__Function__gradient__0 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__1" c_casadi__Function__gradient__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
casadi__Function__gradient__1
  :: Function -> Int -> String -> IO Function
casadi__Function__gradient__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__1 :: FunctionClass a => a -> Int -> String -> IO Function
function_gradient__1 x = casadi__Function__gradient__1 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__2" c_casadi__Function__gradient__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
casadi__Function__gradient__2
  :: Function -> String -> IO Function
casadi__Function__gradient__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__2 :: FunctionClass a => a -> String -> IO Function
function_gradient__2 x = casadi__Function__gradient__2 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__3" c_casadi__Function__gradient__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
casadi__Function__gradient__3
  :: Function -> String -> Int -> IO Function
casadi__Function__gradient__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__3 :: FunctionClass a => a -> String -> Int -> IO Function
function_gradient__3 x = casadi__Function__gradient__3 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__4" c_casadi__Function__gradient__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
casadi__Function__gradient__4
  :: Function -> IO Function
casadi__Function__gradient__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__4 :: FunctionClass a => a -> IO Function
function_gradient__4 x = casadi__Function__gradient__4 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__5" c_casadi__Function__gradient__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
casadi__Function__gradient__5
  :: Function -> Int -> IO Function
casadi__Function__gradient__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__5 :: FunctionClass a => a -> Int -> IO Function
function_gradient__5 x = casadi__Function__gradient__5 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__gradient__6" c_casadi__Function__gradient__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__gradient__6
  :: Function -> Int -> Int -> IO Function
casadi__Function__gradient__6 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__gradient__6 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_gradient__6 :: FunctionClass a => a -> Int -> Int -> IO Function
function_gradient__6 x = casadi__Function__gradient__6 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__0" c_casadi__Function__hessian__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
casadi__Function__hessian__0
  :: Function -> String -> String -> IO Function
casadi__Function__hessian__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__0 :: FunctionClass a => a -> String -> String -> IO Function
function_hessian__0 x = casadi__Function__hessian__0 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__1" c_casadi__Function__hessian__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
casadi__Function__hessian__1
  :: Function -> Int -> String -> IO Function
casadi__Function__hessian__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__1 :: FunctionClass a => a -> Int -> String -> IO Function
function_hessian__1 x = casadi__Function__hessian__1 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__2" c_casadi__Function__hessian__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
casadi__Function__hessian__2
  :: Function -> String -> IO Function
casadi__Function__hessian__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__2 :: FunctionClass a => a -> String -> IO Function
function_hessian__2 x = casadi__Function__hessian__2 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__3" c_casadi__Function__hessian__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
casadi__Function__hessian__3
  :: Function -> String -> Int -> IO Function
casadi__Function__hessian__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__3 :: FunctionClass a => a -> String -> Int -> IO Function
function_hessian__3 x = casadi__Function__hessian__3 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__4" c_casadi__Function__hessian__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
casadi__Function__hessian__4
  :: Function -> IO Function
casadi__Function__hessian__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__4 :: FunctionClass a => a -> IO Function
function_hessian__4 x = casadi__Function__hessian__4 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__5" c_casadi__Function__hessian__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
casadi__Function__hessian__5
  :: Function -> Int -> IO Function
casadi__Function__hessian__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__5 :: FunctionClass a => a -> Int -> IO Function
function_hessian__5 x = casadi__Function__hessian__5 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__hessian__6" c_casadi__Function__hessian__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__hessian__6
  :: Function -> Int -> Int -> IO Function
casadi__Function__hessian__6 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__hessian__6 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_hessian__6 :: FunctionClass a => a -> Int -> Int -> IO Function
function_hessian__6 x = casadi__Function__hessian__6 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__inputScheme__0" c_casadi__Function__inputScheme__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme')
casadi__Function__inputScheme__0
  :: Function -> IO IOScheme
casadi__Function__inputScheme__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__inputScheme__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_inputScheme__0 :: FunctionClass a => a -> IO IOScheme
function_inputScheme__0 x = casadi__Function__inputScheme__0 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__inputScheme__1" c_casadi__Function__inputScheme__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme')
casadi__Function__inputScheme__1
  :: Function -> IO IOScheme
casadi__Function__inputScheme__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__inputScheme__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_inputScheme__1 :: FunctionClass a => a -> IO IOScheme
function_inputScheme__1 x = casadi__Function__inputScheme__1 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__0" c_casadi__Function__jacSparsity__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__0
  :: Function -> String -> String -> IO Sparsity
casadi__Function__jacSparsity__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__0 :: FunctionClass a => a -> String -> String -> IO Sparsity
function_jacSparsity__0 x = casadi__Function__jacSparsity__0 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__1" c_casadi__Function__jacSparsity__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__1
  :: Function -> String -> String -> Bool -> IO Sparsity
casadi__Function__jacSparsity__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Sparsity
function_jacSparsity__1 x = casadi__Function__jacSparsity__1 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__2" c_casadi__Function__jacSparsity__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__2
  :: Function -> String -> String -> Bool -> Bool -> IO Sparsity
casadi__Function__jacSparsity__2 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__2 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Sparsity
function_jacSparsity__2 x = casadi__Function__jacSparsity__2 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__3" c_casadi__Function__jacSparsity__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__3
  :: Function -> Int -> String -> IO Sparsity
casadi__Function__jacSparsity__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__3 :: FunctionClass a => a -> Int -> String -> IO Sparsity
function_jacSparsity__3 x = casadi__Function__jacSparsity__3 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__4" c_casadi__Function__jacSparsity__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__4
  :: Function -> Int -> String -> Bool -> IO Sparsity
casadi__Function__jacSparsity__4 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__4 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Sparsity
function_jacSparsity__4 x = casadi__Function__jacSparsity__4 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__5" c_casadi__Function__jacSparsity__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__5
  :: Function -> Int -> String -> Bool -> Bool -> IO Sparsity
casadi__Function__jacSparsity__5 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__5 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Sparsity
function_jacSparsity__5 x = casadi__Function__jacSparsity__5 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__6" c_casadi__Function__jacSparsity__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__6
  :: Function -> String -> IO Sparsity
casadi__Function__jacSparsity__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__6 :: FunctionClass a => a -> String -> IO Sparsity
function_jacSparsity__6 x = casadi__Function__jacSparsity__6 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__7" c_casadi__Function__jacSparsity__7
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__7
  :: Function -> String -> Int -> IO Sparsity
casadi__Function__jacSparsity__7 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__7 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__7 :: FunctionClass a => a -> String -> Int -> IO Sparsity
function_jacSparsity__7 x = casadi__Function__jacSparsity__7 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__8" c_casadi__Function__jacSparsity__8
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__8
  :: Function -> String -> Int -> Bool -> IO Sparsity
casadi__Function__jacSparsity__8 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__8 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Sparsity
function_jacSparsity__8 x = casadi__Function__jacSparsity__8 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__9" c_casadi__Function__jacSparsity__9
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__9
  :: Function -> String -> Int -> Bool -> Bool -> IO Sparsity
casadi__Function__jacSparsity__9 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__9 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Sparsity
function_jacSparsity__9 x = casadi__Function__jacSparsity__9 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__10" c_casadi__Function__jacSparsity__10
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__10
  :: Function -> IO Sparsity
casadi__Function__jacSparsity__10 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__10 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__10 :: FunctionClass a => a -> IO Sparsity
function_jacSparsity__10 x = casadi__Function__jacSparsity__10 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__11" c_casadi__Function__jacSparsity__11
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__11
  :: Function -> Int -> IO Sparsity
casadi__Function__jacSparsity__11 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__11 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__11 :: FunctionClass a => a -> Int -> IO Sparsity
function_jacSparsity__11 x = casadi__Function__jacSparsity__11 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__12" c_casadi__Function__jacSparsity__12
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__12
  :: Function -> Int -> Int -> IO Sparsity
casadi__Function__jacSparsity__12 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__12 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__12 :: FunctionClass a => a -> Int -> Int -> IO Sparsity
function_jacSparsity__12 x = casadi__Function__jacSparsity__12 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__13" c_casadi__Function__jacSparsity__13
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__13
  :: Function -> Int -> Int -> Bool -> IO Sparsity
casadi__Function__jacSparsity__13 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__13 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Sparsity
function_jacSparsity__13 x = casadi__Function__jacSparsity__13 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__jacSparsity__14" c_casadi__Function__jacSparsity__14
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Function__jacSparsity__14
  :: Function -> Int -> Int -> Bool -> Bool -> IO Sparsity
casadi__Function__jacSparsity__14 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacSparsity__14 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacSparsity__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Sparsity
function_jacSparsity__14 x = casadi__Function__jacSparsity__14 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__0" c_casadi__Function__jacobian__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
casadi__Function__jacobian__0
  :: Function -> String -> String -> IO Function
casadi__Function__jacobian__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__0 :: FunctionClass a => a -> String -> String -> IO Function
function_jacobian__0 x = casadi__Function__jacobian__0 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__1" c_casadi__Function__jacobian__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__1
  :: Function -> String -> String -> Bool -> IO Function
casadi__Function__jacobian__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Function
function_jacobian__1 x = casadi__Function__jacobian__1 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__2" c_casadi__Function__jacobian__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__2
  :: Function -> String -> String -> Bool -> Bool -> IO Function
casadi__Function__jacobian__2 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__2 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Function
function_jacobian__2 x = casadi__Function__jacobian__2 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__3" c_casadi__Function__jacobian__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
casadi__Function__jacobian__3
  :: Function -> Int -> String -> IO Function
casadi__Function__jacobian__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__3 :: FunctionClass a => a -> Int -> String -> IO Function
function_jacobian__3 x = casadi__Function__jacobian__3 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__4" c_casadi__Function__jacobian__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__4
  :: Function -> Int -> String -> Bool -> IO Function
casadi__Function__jacobian__4 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__4 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Function
function_jacobian__4 x = casadi__Function__jacobian__4 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__5" c_casadi__Function__jacobian__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__5
  :: Function -> Int -> String -> Bool -> Bool -> IO Function
casadi__Function__jacobian__5 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__5 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Function
function_jacobian__5 x = casadi__Function__jacobian__5 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__6" c_casadi__Function__jacobian__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
casadi__Function__jacobian__6
  :: Function -> String -> IO Function
casadi__Function__jacobian__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__6 :: FunctionClass a => a -> String -> IO Function
function_jacobian__6 x = casadi__Function__jacobian__6 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__7" c_casadi__Function__jacobian__7
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__7
  :: Function -> String -> Int -> IO Function
casadi__Function__jacobian__7 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__7 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__7 :: FunctionClass a => a -> String -> Int -> IO Function
function_jacobian__7 x = casadi__Function__jacobian__7 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__8" c_casadi__Function__jacobian__8
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__8
  :: Function -> String -> Int -> Bool -> IO Function
casadi__Function__jacobian__8 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__8 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Function
function_jacobian__8 x = casadi__Function__jacobian__8 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__9" c_casadi__Function__jacobian__9
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__9
  :: Function -> String -> Int -> Bool -> Bool -> IO Function
casadi__Function__jacobian__9 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__9 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Function
function_jacobian__9 x = casadi__Function__jacobian__9 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__10" c_casadi__Function__jacobian__10
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
casadi__Function__jacobian__10
  :: Function -> IO Function
casadi__Function__jacobian__10 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__10 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__10 :: FunctionClass a => a -> IO Function
function_jacobian__10 x = casadi__Function__jacobian__10 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__11" c_casadi__Function__jacobian__11
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__11
  :: Function -> Int -> IO Function
casadi__Function__jacobian__11 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__11 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__11 :: FunctionClass a => a -> Int -> IO Function
function_jacobian__11 x = casadi__Function__jacobian__11 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__12" c_casadi__Function__jacobian__12
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__12
  :: Function -> Int -> Int -> IO Function
casadi__Function__jacobian__12 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__12 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__12 :: FunctionClass a => a -> Int -> Int -> IO Function
function_jacobian__12 x = casadi__Function__jacobian__12 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__13" c_casadi__Function__jacobian__13
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__13
  :: Function -> Int -> Int -> Bool -> IO Function
casadi__Function__jacobian__13 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__13 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Function
function_jacobian__13 x = casadi__Function__jacobian__13 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__jacobian__14" c_casadi__Function__jacobian__14
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__jacobian__14
  :: Function -> Int -> Int -> Bool -> Bool -> IO Function
casadi__Function__jacobian__14 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__jacobian__14 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_jacobian__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Function
function_jacobian__14 x = casadi__Function__jacobian__14 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__outputScheme__0" c_casadi__Function__outputScheme__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme')
casadi__Function__outputScheme__0
  :: Function -> IO IOScheme
casadi__Function__outputScheme__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__outputScheme__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_outputScheme__0 :: FunctionClass a => a -> IO IOScheme
function_outputScheme__0 x = casadi__Function__outputScheme__0 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__outputScheme__1" c_casadi__Function__outputScheme__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme')
casadi__Function__outputScheme__1
  :: Function -> IO IOScheme
casadi__Function__outputScheme__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__outputScheme__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_outputScheme__1 :: FunctionClass a => a -> IO IOScheme
function_outputScheme__1 x = casadi__Function__outputScheme__1 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__removeMonitor" c_casadi__Function__removeMonitor
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO ()
casadi__Function__removeMonitor
  :: Function -> String -> IO ()
casadi__Function__removeMonitor x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__removeMonitor errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_removeMonitor :: FunctionClass a => a -> String -> IO ()
function_removeMonitor x = casadi__Function__removeMonitor (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setDerivative" c_casadi__Function__setDerivative
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO ()
casadi__Function__setDerivative
  :: Function -> Function -> Int -> Int -> IO ()
casadi__Function__setDerivative x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setDerivative errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setDerivative :: FunctionClass a => a -> Function -> Int -> Int -> IO ()
function_setDerivative x = casadi__Function__setDerivative (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setFullJacobian" c_casadi__Function__setFullJacobian
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO ()
casadi__Function__setFullJacobian
  :: Function -> Function -> IO ()
casadi__Function__setFullJacobian x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setFullJacobian errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setFullJacobian :: FunctionClass a => a -> Function -> IO ()
function_setFullJacobian x = casadi__Function__setFullJacobian (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setInputScheme" c_casadi__Function__setInputScheme
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr IOScheme' -> IO ()
casadi__Function__setInputScheme
  :: Function -> IOScheme -> IO ()
casadi__Function__setInputScheme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setInputScheme errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setInputScheme :: FunctionClass a => a -> IOScheme -> IO ()
function_setInputScheme x = casadi__Function__setInputScheme (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__0" c_casadi__Function__setJacSparsity__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> IO ()
casadi__Function__setJacSparsity__0
  :: Function -> Sparsity -> String -> String -> IO ()
casadi__Function__setJacSparsity__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__0 :: FunctionClass a => a -> Sparsity -> String -> String -> IO ()
function_setJacSparsity__0 x = casadi__Function__setJacSparsity__0 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__1" c_casadi__Function__setJacSparsity__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> CInt -> IO ()
casadi__Function__setJacSparsity__1
  :: Function -> Sparsity -> String -> String -> Bool -> IO ()
casadi__Function__setJacSparsity__1 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__1 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__1 :: FunctionClass a => a -> Sparsity -> String -> String -> Bool -> IO ()
function_setJacSparsity__1 x = casadi__Function__setJacSparsity__1 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__2" c_casadi__Function__setJacSparsity__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> IO ()
casadi__Function__setJacSparsity__2
  :: Function -> Sparsity -> Int -> String -> IO ()
casadi__Function__setJacSparsity__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__2 :: FunctionClass a => a -> Sparsity -> Int -> String -> IO ()
function_setJacSparsity__2 x = casadi__Function__setJacSparsity__2 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__3" c_casadi__Function__setJacSparsity__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> CInt -> IO ()
casadi__Function__setJacSparsity__3
  :: Function -> Sparsity -> Int -> String -> Bool -> IO ()
casadi__Function__setJacSparsity__3 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__3 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__3 :: FunctionClass a => a -> Sparsity -> Int -> String -> Bool -> IO ()
function_setJacSparsity__3 x = casadi__Function__setJacSparsity__3 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__4" c_casadi__Function__setJacSparsity__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> IO ()
casadi__Function__setJacSparsity__4
  :: Function -> Sparsity -> String -> Int -> IO ()
casadi__Function__setJacSparsity__4 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__4 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__4 :: FunctionClass a => a -> Sparsity -> String -> Int -> IO ()
function_setJacSparsity__4 x = casadi__Function__setJacSparsity__4 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__5" c_casadi__Function__setJacSparsity__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> CInt -> IO ()
casadi__Function__setJacSparsity__5
  :: Function -> Sparsity -> String -> Int -> Bool -> IO ()
casadi__Function__setJacSparsity__5 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__5 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__5 :: FunctionClass a => a -> Sparsity -> String -> Int -> Bool -> IO ()
function_setJacSparsity__5 x = casadi__Function__setJacSparsity__5 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__6" c_casadi__Function__setJacSparsity__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> IO ()
casadi__Function__setJacSparsity__6
  :: Function -> Sparsity -> Int -> Int -> IO ()
casadi__Function__setJacSparsity__6 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__6 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__6 :: FunctionClass a => a -> Sparsity -> Int -> Int -> IO ()
function_setJacSparsity__6 x = casadi__Function__setJacSparsity__6 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacSparsity__7" c_casadi__Function__setJacSparsity__7
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> CInt -> IO ()
casadi__Function__setJacSparsity__7
  :: Function -> Sparsity -> Int -> Int -> Bool -> IO ()
casadi__Function__setJacSparsity__7 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacSparsity__7 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacSparsity__7 :: FunctionClass a => a -> Sparsity -> Int -> Int -> Bool -> IO ()
function_setJacSparsity__7 x = casadi__Function__setJacSparsity__7 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacobian__0" c_casadi__Function__setJacobian__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO ()
casadi__Function__setJacobian__0
  :: Function -> Function -> IO ()
casadi__Function__setJacobian__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacobian__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacobian__0 :: FunctionClass a => a -> Function -> IO ()
function_setJacobian__0 x = casadi__Function__setJacobian__0 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacobian__1" c_casadi__Function__setJacobian__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO ()
casadi__Function__setJacobian__1
  :: Function -> Function -> Int -> IO ()
casadi__Function__setJacobian__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacobian__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacobian__1 :: FunctionClass a => a -> Function -> Int -> IO ()
function_setJacobian__1 x = casadi__Function__setJacobian__1 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacobian__2" c_casadi__Function__setJacobian__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO ()
casadi__Function__setJacobian__2
  :: Function -> Function -> Int -> Int -> IO ()
casadi__Function__setJacobian__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacobian__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacobian__2 :: FunctionClass a => a -> Function -> Int -> Int -> IO ()
function_setJacobian__2 x = casadi__Function__setJacobian__2 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setJacobian__3" c_casadi__Function__setJacobian__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> CInt -> IO ()
casadi__Function__setJacobian__3
  :: Function -> Function -> Int -> Int -> Bool -> IO ()
casadi__Function__setJacobian__3 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setJacobian__3 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setJacobian__3 :: FunctionClass a => a -> Function -> Int -> Int -> Bool -> IO ()
function_setJacobian__3 x = casadi__Function__setJacobian__3 (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__setOutputScheme" c_casadi__Function__setOutputScheme
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr IOScheme' -> IO ()
casadi__Function__setOutputScheme
  :: Function -> IOScheme -> IO ()
casadi__Function__setOutputScheme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__setOutputScheme errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_setOutputScheme :: FunctionClass a => a -> IOScheme -> IO ()
function_setOutputScheme x = casadi__Function__setOutputScheme (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__spCanEvaluate" c_casadi__Function__spCanEvaluate
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt
casadi__Function__spCanEvaluate
  :: Function -> Bool -> IO Bool
casadi__Function__spCanEvaluate x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__spCanEvaluate errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_spCanEvaluate :: FunctionClass a => a -> Bool -> IO Bool
function_spCanEvaluate x = casadi__Function__spCanEvaluate (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__spEvaluate" c_casadi__Function__spEvaluate
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO ()
casadi__Function__spEvaluate
  :: Function -> Bool -> IO ()
casadi__Function__spEvaluate x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__spEvaluate errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_spEvaluate :: FunctionClass a => a -> Bool -> IO ()
function_spEvaluate x = casadi__Function__spEvaluate (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__spInit" c_casadi__Function__spInit
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO ()
casadi__Function__spInit
  :: Function -> Bool -> IO ()
casadi__Function__spInit x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__spInit errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_spInit :: FunctionClass a => a -> Bool -> IO ()
function_spInit x = casadi__Function__spInit (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__symbolicInput" c_casadi__Function__symbolicInput
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX')))
casadi__Function__symbolicInput
  :: Function -> IO (Vector MX)
casadi__Function__symbolicInput x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__symbolicInput errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_symbolicInput :: FunctionClass a => a -> IO (Vector MX)
function_symbolicInput x = casadi__Function__symbolicInput (castFunction x)


-- direct wrapper
foreign import ccall unsafe "casadi__Function__symbolicInputSX" c_casadi__Function__symbolicInputSX
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX')))
casadi__Function__symbolicInputSX
  :: Function -> IO (Vector SX)
casadi__Function__symbolicInputSX x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__symbolicInputSX errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_symbolicInputSX :: FunctionClass a => a -> IO (Vector SX)
function_symbolicInputSX x = casadi__Function__symbolicInputSX (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__0" c_casadi__Function__tangent__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function')
casadi__Function__tangent__0
  :: Function -> String -> String -> IO Function
casadi__Function__tangent__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__0 :: FunctionClass a => a -> String -> String -> IO Function
function_tangent__0 x = casadi__Function__tangent__0 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__1" c_casadi__Function__tangent__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function')
casadi__Function__tangent__1
  :: Function -> Int -> String -> IO Function
casadi__Function__tangent__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__1 :: FunctionClass a => a -> Int -> String -> IO Function
function_tangent__1 x = casadi__Function__tangent__1 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__2" c_casadi__Function__tangent__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
casadi__Function__tangent__2
  :: Function -> String -> IO Function
casadi__Function__tangent__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__2 :: FunctionClass a => a -> String -> IO Function
function_tangent__2 x = casadi__Function__tangent__2 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__3" c_casadi__Function__tangent__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function')
casadi__Function__tangent__3
  :: Function -> String -> Int -> IO Function
casadi__Function__tangent__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__3 :: FunctionClass a => a -> String -> Int -> IO Function
function_tangent__3 x = casadi__Function__tangent__3 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__4" c_casadi__Function__tangent__4
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
casadi__Function__tangent__4
  :: Function -> IO Function
casadi__Function__tangent__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__4 :: FunctionClass a => a -> IO Function
function_tangent__4 x = casadi__Function__tangent__4 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__5" c_casadi__Function__tangent__5
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function')
casadi__Function__tangent__5
  :: Function -> Int -> IO Function
casadi__Function__tangent__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__5 :: FunctionClass a => a -> Int -> IO Function
function_tangent__5 x = casadi__Function__tangent__5 (castFunction x)


-- direct wrapper
foreign import ccall safe "casadi__Function__tangent__6" c_casadi__Function__tangent__6
  :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function')
casadi__Function__tangent__6
  :: Function -> Int -> Int -> IO Function
casadi__Function__tangent__6 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Function__tangent__6 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
function_tangent__6 :: FunctionClass a => a -> Int -> Int -> IO Function
function_tangent__6 x = casadi__Function__tangent__6 (castFunction x)