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

module Casadi.Core.Classes.MXFunction
       (
         MXFunction,
         MXFunctionClass(..),
         mxFunction__0,
         mxFunction__1,
         mxFunction__2,
         mxFunction_countNodes,
         mxFunction_expand__0,
         mxFunction_expand__1,
         mxFunction_generateLiftingFunctions,
         mxFunction_getAlgorithmSize,
         mxFunction_getFree,
         mxFunction_getWorkSize,
         mxFunction_grad__0,
         mxFunction_grad__1,
         mxFunction_grad__2,
         mxFunction_grad__3,
         mxFunction_grad__4,
         mxFunction_grad__5,
         mxFunction_grad__6,
         mxFunction_inputExpr__0,
         mxFunction_inputExpr__1,
         mxFunction_inputExpr__2,
         mxFunction_jac__0,
         mxFunction_jac__1,
         mxFunction_jac__10,
         mxFunction_jac__11,
         mxFunction_jac__12,
         mxFunction_jac__13,
         mxFunction_jac__14,
         mxFunction_jac__2,
         mxFunction_jac__3,
         mxFunction_jac__4,
         mxFunction_jac__5,
         mxFunction_jac__6,
         mxFunction_jac__7,
         mxFunction_jac__8,
         mxFunction_jac__9,
         mxFunction_outputExpr__0,
         mxFunction_outputExpr__1,
         mxFunction_outputExpr__2,
         mxFunction_tang__0,
         mxFunction_tang__1,
         mxFunction_tang__2,
         mxFunction_tang__3,
         mxFunction_tang__4,
         mxFunction_tang__5,
         mxFunction_tang__6,
       ) where


import Prelude hiding ( Functor )

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

import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums
-- direct wrapper
foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__0" c_casadi__MXFunction__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MXFunction')
casadi__MXFunction__CONSTRUCTOR__0
  :: Vector MX -> Vector MX -> IO MXFunction
casadi__MXFunction__CONSTRUCTOR__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mxFunction__0 :: Vector MX -> Vector MX -> IO MXFunction
mxFunction__0 = casadi__MXFunction__CONSTRUCTOR__0


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


-- classy wrapper
mxFunction__1 :: Function -> IO MXFunction
mxFunction__1 = casadi__MXFunction__CONSTRUCTOR__1


-- direct wrapper
foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__2" c_casadi__MXFunction__CONSTRUCTOR__2
  :: Ptr (Ptr StdString) -> IO (Ptr MXFunction')
casadi__MXFunction__CONSTRUCTOR__2
  :: IO MXFunction
casadi__MXFunction__CONSTRUCTOR__2  =

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


-- classy wrapper
mxFunction__2 :: IO MXFunction
mxFunction__2 = casadi__MXFunction__CONSTRUCTOR__2


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


-- classy wrapper
mxFunction_countNodes :: MXFunctionClass a => a -> IO Int
mxFunction_countNodes x = casadi__MXFunction__countNodes (castMXFunction x)


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


-- classy wrapper
mxFunction_expand__0 :: MXFunctionClass a => a -> IO SXFunction
mxFunction_expand__0 x = casadi__MXFunction__expand__0 (castMXFunction x)


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


-- classy wrapper
mxFunction_expand__1 :: MXFunctionClass a => a -> Vector SX -> IO SXFunction
mxFunction_expand__1 x = casadi__MXFunction__expand__1 (castMXFunction x)


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


-- classy wrapper
mxFunction_generateLiftingFunctions :: MXFunctionClass a => a -> MXFunction -> MXFunction -> IO ()
mxFunction_generateLiftingFunctions x = casadi__MXFunction__generateLiftingFunctions (castMXFunction x)


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


-- classy wrapper
mxFunction_getAlgorithmSize :: MXFunctionClass a => a -> IO Int
mxFunction_getAlgorithmSize x = casadi__MXFunction__getAlgorithmSize (castMXFunction x)


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


-- classy wrapper
mxFunction_getFree :: MXFunctionClass a => a -> IO (Vector MX)
mxFunction_getFree x = casadi__MXFunction__getFree (castMXFunction x)


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


-- classy wrapper
mxFunction_getWorkSize :: MXFunctionClass a => a -> IO Int
mxFunction_getWorkSize x = casadi__MXFunction__getWorkSize (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__0 :: MXFunctionClass a => a -> String -> String -> IO MX
mxFunction_grad__0 x = casadi__MXFunction__grad__0 (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__1 :: MXFunctionClass a => a -> Int -> String -> IO MX
mxFunction_grad__1 x = casadi__MXFunction__grad__1 (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__2 :: MXFunctionClass a => a -> String -> IO MX
mxFunction_grad__2 x = casadi__MXFunction__grad__2 (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__3 :: MXFunctionClass a => a -> String -> Int -> IO MX
mxFunction_grad__3 x = casadi__MXFunction__grad__3 (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__4 :: MXFunctionClass a => a -> IO MX
mxFunction_grad__4 x = casadi__MXFunction__grad__4 (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__5 :: MXFunctionClass a => a -> Int -> IO MX
mxFunction_grad__5 x = casadi__MXFunction__grad__5 (castMXFunction x)


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


-- classy wrapper
mxFunction_grad__6 :: MXFunctionClass a => a -> Int -> Int -> IO MX
mxFunction_grad__6 x = casadi__MXFunction__grad__6 (castMXFunction x)


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


-- classy wrapper
mxFunction_inputExpr__0 :: MXFunctionClass a => a -> IO (Vector MX)
mxFunction_inputExpr__0 x = casadi__MXFunction__inputExpr__0 (castMXFunction x)


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


-- classy wrapper
mxFunction_inputExpr__1 :: MXFunctionClass a => a -> String -> IO MX
mxFunction_inputExpr__1 x = casadi__MXFunction__inputExpr__1 (castMXFunction x)


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


-- classy wrapper
mxFunction_inputExpr__2 :: MXFunctionClass a => a -> Int -> IO MX
mxFunction_inputExpr__2 x = casadi__MXFunction__inputExpr__2 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__0 :: MXFunctionClass a => a -> String -> String -> IO MX
mxFunction_jac__0 x = casadi__MXFunction__jac__0 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__1 :: MXFunctionClass a => a -> String -> String -> Bool -> IO MX
mxFunction_jac__1 x = casadi__MXFunction__jac__1 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__2 :: MXFunctionClass a => a -> String -> String -> Bool -> Bool -> IO MX
mxFunction_jac__2 x = casadi__MXFunction__jac__2 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__3 :: MXFunctionClass a => a -> Int -> String -> IO MX
mxFunction_jac__3 x = casadi__MXFunction__jac__3 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__4 :: MXFunctionClass a => a -> Int -> String -> Bool -> IO MX
mxFunction_jac__4 x = casadi__MXFunction__jac__4 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__5 :: MXFunctionClass a => a -> Int -> String -> Bool -> Bool -> IO MX
mxFunction_jac__5 x = casadi__MXFunction__jac__5 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__6 :: MXFunctionClass a => a -> String -> IO MX
mxFunction_jac__6 x = casadi__MXFunction__jac__6 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__7 :: MXFunctionClass a => a -> String -> Int -> IO MX
mxFunction_jac__7 x = casadi__MXFunction__jac__7 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__8 :: MXFunctionClass a => a -> String -> Int -> Bool -> IO MX
mxFunction_jac__8 x = casadi__MXFunction__jac__8 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__9 :: MXFunctionClass a => a -> String -> Int -> Bool -> Bool -> IO MX
mxFunction_jac__9 x = casadi__MXFunction__jac__9 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__10 :: MXFunctionClass a => a -> IO MX
mxFunction_jac__10 x = casadi__MXFunction__jac__10 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__11 :: MXFunctionClass a => a -> Int -> IO MX
mxFunction_jac__11 x = casadi__MXFunction__jac__11 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__12 :: MXFunctionClass a => a -> Int -> Int -> IO MX
mxFunction_jac__12 x = casadi__MXFunction__jac__12 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__13 :: MXFunctionClass a => a -> Int -> Int -> Bool -> IO MX
mxFunction_jac__13 x = casadi__MXFunction__jac__13 (castMXFunction x)


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


-- classy wrapper
mxFunction_jac__14 :: MXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO MX
mxFunction_jac__14 x = casadi__MXFunction__jac__14 (castMXFunction x)


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


-- classy wrapper
mxFunction_outputExpr__0 :: MXFunctionClass a => a -> IO (Vector MX)
mxFunction_outputExpr__0 x = casadi__MXFunction__outputExpr__0 (castMXFunction x)


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


-- classy wrapper
mxFunction_outputExpr__1 :: MXFunctionClass a => a -> String -> IO MX
mxFunction_outputExpr__1 x = casadi__MXFunction__outputExpr__1 (castMXFunction x)


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


-- classy wrapper
mxFunction_outputExpr__2 :: MXFunctionClass a => a -> Int -> IO MX
mxFunction_outputExpr__2 x = casadi__MXFunction__outputExpr__2 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__0 :: MXFunctionClass a => a -> String -> String -> IO MX
mxFunction_tang__0 x = casadi__MXFunction__tang__0 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__1 :: MXFunctionClass a => a -> Int -> String -> IO MX
mxFunction_tang__1 x = casadi__MXFunction__tang__1 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__2 :: MXFunctionClass a => a -> String -> IO MX
mxFunction_tang__2 x = casadi__MXFunction__tang__2 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__3 :: MXFunctionClass a => a -> String -> Int -> IO MX
mxFunction_tang__3 x = casadi__MXFunction__tang__3 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__4 :: MXFunctionClass a => a -> IO MX
mxFunction_tang__4 x = casadi__MXFunction__tang__4 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__5 :: MXFunctionClass a => a -> Int -> IO MX
mxFunction_tang__5 x = casadi__MXFunction__tang__5 (castMXFunction x)


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


-- classy wrapper
mxFunction_tang__6 :: MXFunctionClass a => a -> Int -> Int -> IO MX
mxFunction_tang__6 x = casadi__MXFunction__tang__6 (castMXFunction x)