casadi-bindings-core-2.4.1.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_callForward__0,
         function_callForward__1,
         function_callForward__2,
         function_callForward__3,
         function_callForward__4,
         function_callForward__5,
         function_callForward__6,
         function_callForward__7,
         function_callForward__8,
         function_callReverse__0,
         function_callReverse__1,
         function_callReverse__2,
         function_callReverse__3,
         function_callReverse__4,
         function_callReverse__5,
         function_callReverse__6,
         function_callReverse__7,
         function_callReverse__8,
         function_call__0,
         function_call__1,
         function_call__2,
         function_call__3,
         function_call__4,
         function_call__5,
         function_call__6,
         function_call__7,
         function_call__8,
         function_checkInputs,
         function_defaultInput,
         function_derForward,
         function_derReverse,
         function_derivative,
         function_evaluate,
         function_fullJacobian,
         function_generate__0,
         function_generate__1,
         function_generate__2,
         function_generate__3,
         function_getSanitizedName,
         function_getStat,
         function_getStats,
         function_gradient__0,
         function_gradient__1,
         function_gradient__2,
         function_gradient__3,
         function_gradient__4,
         function_gradient__5,
         function_gradient__6,
         function_hessian__0,
         function_hessian__1,
         function_hessian__2,
         function_hessian__3,
         function_hessian__4,
         function_hessian__5,
         function_hessian__6,
         function_inputDescription,
         function_inputIndex,
         function_inputName,
         function_inputScheme,
         function_inputSparsity__0,
         function_inputSparsity__1,
         function_inputSparsity__2,
         function_jacSparsity__0,
         function_jacSparsity__1,
         function_jacSparsity__10,
         function_jacSparsity__11,
         function_jacSparsity__12,
         function_jacSparsity__13,
         function_jacSparsity__14,
         function_jacSparsity__2,
         function_jacSparsity__3,
         function_jacSparsity__4,
         function_jacSparsity__5,
         function_jacSparsity__6,
         function_jacSparsity__7,
         function_jacSparsity__8,
         function_jacSparsity__9,
         function_jacobian__0,
         function_jacobian__1,
         function_jacobian__10,
         function_jacobian__11,
         function_jacobian__12,
         function_jacobian__13,
         function_jacobian__14,
         function_jacobian__2,
         function_jacobian__3,
         function_jacobian__4,
         function_jacobian__5,
         function_jacobian__6,
         function_jacobian__7,
         function_jacobian__8,
         function_jacobian__9,
         function_map__0,
         function_map__1,
         function_map__2,
         function_map__3,
         function_map__4,
         function_map__5,
         function_mapaccum__0,
         function_mapaccum__1,
         function_mapsum__0,
         function_mapsum__1,
         function_nIn,
         function_nOut,
         function_nnzIn,
         function_nnzOut,
         function_numelIn,
         function_numelOut,
         function_operator_call__0,
         function_operator_call__1,
         function_operator_call__10,
         function_operator_call__11,
         function_operator_call__12,
         function_operator_call__13,
         function_operator_call__14,
         function_operator_call__15,
         function_operator_call__16,
         function_operator_call__17,
         function_operator_call__2,
         function_operator_call__3,
         function_operator_call__4,
         function_operator_call__5,
         function_operator_call__6,
         function_operator_call__7,
         function_operator_call__8,
         function_operator_call__9,
         function_outputDescription,
         function_outputIndex,
         function_outputName,
         function_outputScheme,
         function_outputSparsity__0,
         function_outputSparsity__1,
         function_outputSparsity__2,
         function_printDimensions,
         function_removeMonitor,
         function_sanitizeName,
         function_setDerForward,
         function_setDerReverse,
         function_setFullJacobian,
         function_setJacSparsity__0,
         function_setJacSparsity__1,
         function_setJacSparsity__2,
         function_setJacSparsity__3,
         function_setJacSparsity__4,
         function_setJacSparsity__5,
         function_setJacSparsity__6,
         function_setJacSparsity__7,
         function_setJacobian__0,
         function_setJacobian__1,
         function_setJacobian__2,
         function_setJacobian__3,
         function_spCanEvaluate,
         function_spEvaluate,
         function_spInit,
         function_symbolicInputSX,
         function_symbolicInput__0,
         function_symbolicInput__1,
         function_symbolicOutput,
         function_sz_arg,
         function_sz_iw,
         function_sz_res,
         function_sz_w,
         function_tangent__0,
         function_tangent__1,
         function_tangent__2,
         function_tangent__3,
         function_tangent__4,
         function_tangent__5,
         function_tangent__6,
       ) where


import Prelude hiding ( Functor )

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

import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums
-- direct wrapper
foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR
  :: Ptr (Ptr StdString) -> IO (Ptr Function')
casadi__Function__CONSTRUCTOR
  :: IO Function
casadi__Function__CONSTRUCTOR  =

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- classy wrapper
function_callForward__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
function_callForward__0 x = casadi__Function__callForward__0 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_callForward__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
function_callForward__3 x = casadi__Function__callForward__3 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_callForward__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
function_callForward__6 x = casadi__Function__callForward__6 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_callReverse__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO ()
function_callReverse__0 x = casadi__Function__callReverse__0 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_callReverse__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO ()
function_callReverse__3 x = casadi__Function__callReverse__3 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_callReverse__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO ()
function_callReverse__6 x = casadi__Function__callReverse__6 (castFunction x)


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


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


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


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


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


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


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


-- classy wrapper
function_defaultInput :: FunctionClass a => a -> Int -> IO Double
function_defaultInput x = casadi__Function__defaultInput (castFunction x)


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


-- classy wrapper
function_derForward :: FunctionClass a => a -> Int -> IO Function
function_derForward x = casadi__Function__derForward (castFunction x)


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


-- classy wrapper
function_derReverse :: FunctionClass a => a -> Int -> IO Function
function_derReverse x = casadi__Function__derReverse (castFunction x)


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


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


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


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


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


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


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


-- classy wrapper
function_generate__0 :: FunctionClass a => a -> IO ()
function_generate__0 x = casadi__Function__generate__0 (castFunction x)


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


-- classy wrapper
function_generate__1 :: FunctionClass a => a -> M.Map String GenericType -> IO ()
function_generate__1 x = casadi__Function__generate__1 (castFunction x)


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


-- classy wrapper
function_generate__2 :: FunctionClass a => a -> String -> IO ()
function_generate__2 x = casadi__Function__generate__2 (castFunction x)


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


-- classy wrapper
function_generate__3 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO ()
function_generate__3 x = casadi__Function__generate__3 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_getStats :: FunctionClass a => a -> IO (M.Map String GenericType)
function_getStats x = casadi__Function__getStats (castFunction x)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- classy wrapper
function_inputDescription :: FunctionClass a => a -> Int -> IO String
function_inputDescription x = casadi__Function__inputDescription (castFunction x)


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


-- classy wrapper
function_inputIndex :: FunctionClass a => a -> String -> IO Int
function_inputIndex x = casadi__Function__inputIndex (castFunction x)


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


-- classy wrapper
function_inputName :: FunctionClass a => a -> Int -> IO String
function_inputName x = casadi__Function__inputName (castFunction x)


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


-- classy wrapper
function_inputScheme :: FunctionClass a => a -> IO (Vector String)
function_inputScheme x = casadi__Function__inputScheme (castFunction x)


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


-- classy wrapper
function_inputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity
function_inputSparsity__0 x = casadi__Function__inputSparsity__0 (castFunction x)


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


-- classy wrapper
function_inputSparsity__1 :: FunctionClass a => a -> IO Sparsity
function_inputSparsity__1 x = casadi__Function__inputSparsity__1 (castFunction x)


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


-- classy wrapper
function_inputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity
function_inputSparsity__2 x = casadi__Function__inputSparsity__2 (castFunction x)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- classy wrapper
function_map__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
function_map__1 x = casadi__Function__map__1 (castFunction x)


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


-- classy wrapper
function_map__2 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
function_map__2 x = casadi__Function__map__2 (castFunction x)


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


-- classy wrapper
function_map__3 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX)
function_map__3 x = casadi__Function__map__3 (castFunction x)


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


-- classy wrapper
function_map__4 :: FunctionClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX))
function_map__4 x = casadi__Function__map__4 (castFunction x)


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


-- classy wrapper
function_map__5 :: FunctionClass a => a -> Vector (Vector MX) -> String -> IO (Vector (Vector MX))
function_map__5 x = casadi__Function__map__5 (castFunction x)


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


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


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


-- classy wrapper
function_mapaccum__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function
function_mapaccum__1 x = casadi__Function__mapaccum__1 (castFunction x)


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


-- classy wrapper
function_mapsum__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
function_mapsum__0 x = casadi__Function__mapsum__0 (castFunction x)


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


-- classy wrapper
function_mapsum__1 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX)
function_mapsum__1 x = casadi__Function__mapsum__1 (castFunction x)


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


-- classy wrapper
function_nIn :: FunctionClass a => a -> IO Int
function_nIn x = casadi__Function__nIn (castFunction x)


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


-- classy wrapper
function_nOut :: FunctionClass a => a -> IO Int
function_nOut x = casadi__Function__nOut (castFunction x)


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


-- classy wrapper
function_nnzIn :: FunctionClass a => a -> IO Int
function_nnzIn x = casadi__Function__nnzIn (castFunction x)


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


-- classy wrapper
function_nnzOut :: FunctionClass a => a -> IO Int
function_nnzOut x = casadi__Function__nnzOut (castFunction x)


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


-- classy wrapper
function_numelIn :: FunctionClass a => a -> IO Int
function_numelIn x = casadi__Function__numelIn (castFunction x)


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


-- classy wrapper
function_numelOut :: FunctionClass a => a -> IO Int
function_numelOut x = casadi__Function__numelOut (castFunction x)


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


-- classy wrapper
function_operator_call__0 :: FunctionClass a => a -> M.Map String MX -> IO (M.Map String MX)
function_operator_call__0 x = casadi__Function__operator_call__0 (castFunction x)


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


-- classy wrapper
function_operator_call__1 :: FunctionClass a => a -> M.Map String MX -> Bool -> IO (M.Map String MX)
function_operator_call__1 x = casadi__Function__operator_call__1 (castFunction x)


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


-- classy wrapper
function_operator_call__2 :: FunctionClass a => a -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX)
function_operator_call__2 x = casadi__Function__operator_call__2 (castFunction x)


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


-- classy wrapper
function_operator_call__3 :: FunctionClass a => a -> M.Map String SX -> IO (M.Map String SX)
function_operator_call__3 x = casadi__Function__operator_call__3 (castFunction x)


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


-- classy wrapper
function_operator_call__4 :: FunctionClass a => a -> M.Map String SX -> Bool -> IO (M.Map String SX)
function_operator_call__4 x = casadi__Function__operator_call__4 (castFunction x)


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


-- classy wrapper
function_operator_call__5 :: FunctionClass a => a -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX)
function_operator_call__5 x = casadi__Function__operator_call__5 (castFunction x)


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


-- classy wrapper
function_operator_call__6 :: FunctionClass a => a -> M.Map String DMatrix -> IO (M.Map String DMatrix)
function_operator_call__6 x = casadi__Function__operator_call__6 (castFunction x)


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


-- classy wrapper
function_operator_call__7 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix)
function_operator_call__7 x = casadi__Function__operator_call__7 (castFunction x)


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


-- classy wrapper
function_operator_call__8 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix)
function_operator_call__8 x = casadi__Function__operator_call__8 (castFunction x)


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


-- classy wrapper
function_operator_call__9 :: FunctionClass a => a -> Vector MX -> IO (Vector MX)
function_operator_call__9 x = casadi__Function__operator_call__9 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_operator_call__12 :: FunctionClass a => a -> Vector SX -> IO (Vector SX)
function_operator_call__12 x = casadi__Function__operator_call__12 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_operator_call__15 :: FunctionClass a => a -> Vector DMatrix -> IO (Vector DMatrix)
function_operator_call__15 x = casadi__Function__operator_call__15 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_outputDescription :: FunctionClass a => a -> Int -> IO String
function_outputDescription x = casadi__Function__outputDescription (castFunction x)


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


-- classy wrapper
function_outputIndex :: FunctionClass a => a -> String -> IO Int
function_outputIndex x = casadi__Function__outputIndex (castFunction x)


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


-- classy wrapper
function_outputName :: FunctionClass a => a -> Int -> IO String
function_outputName x = casadi__Function__outputName (castFunction x)


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


-- classy wrapper
function_outputScheme :: FunctionClass a => a -> IO (Vector String)
function_outputScheme x = casadi__Function__outputScheme (castFunction x)


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


-- classy wrapper
function_outputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity
function_outputSparsity__0 x = casadi__Function__outputSparsity__0 (castFunction x)


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


-- classy wrapper
function_outputSparsity__1 :: FunctionClass a => a -> IO Sparsity
function_outputSparsity__1 x = casadi__Function__outputSparsity__1 (castFunction x)


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


-- classy wrapper
function_outputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity
function_outputSparsity__2 x = casadi__Function__outputSparsity__2 (castFunction x)


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


-- classy wrapper
function_printDimensions :: FunctionClass a => a -> IO ()
function_printDimensions x = casadi__Function__printDimensions (castFunction x)


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


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


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


-- classy wrapper
function_sanitizeName :: String -> IO String
function_sanitizeName = casadi__Function__sanitizeName


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


-- classy wrapper
function_setDerForward :: FunctionClass a => a -> Function -> Int -> IO ()
function_setDerForward x = casadi__Function__setDerForward (castFunction x)


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


-- classy wrapper
function_setDerReverse :: FunctionClass a => a -> Function -> Int -> IO ()
function_setDerReverse x = casadi__Function__setDerReverse (castFunction x)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- classy wrapper
function_symbolicInput__0 :: FunctionClass a => a -> IO (Vector MX)
function_symbolicInput__0 x = casadi__Function__symbolicInput__0 (castFunction x)


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


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


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


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


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


-- classy wrapper
function_symbolicOutput :: FunctionClass a => a -> IO (Vector MX)
function_symbolicOutput x = casadi__Function__symbolicOutput (castFunction x)


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


-- classy wrapper
function_sz_arg :: FunctionClass a => a -> IO CSize
function_sz_arg x = casadi__Function__sz_arg (castFunction x)


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


-- classy wrapper
function_sz_iw :: FunctionClass a => a -> IO CSize
function_sz_iw x = casadi__Function__sz_iw (castFunction x)


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


-- classy wrapper
function_sz_res :: FunctionClass a => a -> IO CSize
function_sz_res x = casadi__Function__sz_res (castFunction x)


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


-- classy wrapper
function_sz_w :: FunctionClass a => a -> IO CSize
function_sz_w x = casadi__Function__sz_w (castFunction x)


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


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


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


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


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


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


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


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


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


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


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


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


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


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