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

module Casadi.Core.Classes.SXFunction
       (
         SXFunction,
         SXFunctionClass(..),
         sxFunction__0,
         sxFunction__1,
         sxFunction__2,
         sxFunction__3,
         sxFunction_clearSymbolic,
         sxFunction_countNodes,
         sxFunction_getAlgorithmSize,
         sxFunction_getAtomicInputReal,
         sxFunction_getAtomicOperation,
         sxFunction_getAtomicOutput,
         sxFunction_getFree,
         sxFunction_getWorkSize,
         sxFunction_grad__0,
         sxFunction_grad__1,
         sxFunction_grad__2,
         sxFunction_grad__3,
         sxFunction_grad__4,
         sxFunction_grad__5,
         sxFunction_grad__6,
         sxFunction_hess__0,
         sxFunction_hess__1,
         sxFunction_hess__2,
         sxFunction_hess__3,
         sxFunction_hess__4,
         sxFunction_hess__5,
         sxFunction_hess__6,
         sxFunction_inputExpr__0,
         sxFunction_inputExpr__1,
         sxFunction_inputExpr__2,
         sxFunction_jac__0,
         sxFunction_jac__1,
         sxFunction_jac__10,
         sxFunction_jac__11,
         sxFunction_jac__12,
         sxFunction_jac__13,
         sxFunction_jac__14,
         sxFunction_jac__2,
         sxFunction_jac__3,
         sxFunction_jac__4,
         sxFunction_jac__5,
         sxFunction_jac__6,
         sxFunction_jac__7,
         sxFunction_jac__8,
         sxFunction_jac__9,
         sxFunction_outputExpr__0,
         sxFunction_outputExpr__1,
         sxFunction_outputExpr__2,
         sxFunction_tang__0,
         sxFunction_tang__1,
         sxFunction_tang__2,
         sxFunction_tang__3,
         sxFunction_tang__4,
         sxFunction_tang__5,
         sxFunction_tang__6,
       ) where


import Prelude hiding ( Functor )

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

import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums

instance Show SXFunction where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__0" c_casadi__SXFunction__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction')
casadi__SXFunction__CONSTRUCTOR__0
  :: Vector SX -> Vector SX -> IO SXFunction
casadi__SXFunction__CONSTRUCTOR__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxFunction__0 :: Vector SX -> Vector SX -> IO SXFunction
sxFunction__0 = casadi__SXFunction__CONSTRUCTOR__0


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


-- classy wrapper
sxFunction__1 :: Function -> IO SXFunction
sxFunction__1 = casadi__SXFunction__CONSTRUCTOR__1


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


-- classy wrapper
sxFunction__2 :: MXFunction -> IO SXFunction
sxFunction__2 = casadi__SXFunction__CONSTRUCTOR__2


-- direct wrapper
foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__3" c_casadi__SXFunction__CONSTRUCTOR__3
  :: Ptr (Ptr StdString) -> IO (Ptr SXFunction')
casadi__SXFunction__CONSTRUCTOR__3
  :: IO SXFunction
casadi__SXFunction__CONSTRUCTOR__3  =

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


-- classy wrapper
sxFunction__3 :: IO SXFunction
sxFunction__3 = casadi__SXFunction__CONSTRUCTOR__3


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


-- classy wrapper
sxFunction_clearSymbolic :: SXFunctionClass a => a -> IO ()
sxFunction_clearSymbolic x = casadi__SXFunction__clearSymbolic (castSXFunction x)


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


-- classy wrapper
sxFunction_countNodes :: SXFunctionClass a => a -> IO Int
sxFunction_countNodes x = casadi__SXFunction__countNodes (castSXFunction x)


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


-- classy wrapper
sxFunction_getAlgorithmSize :: SXFunctionClass a => a -> IO Int
sxFunction_getAlgorithmSize x = casadi__SXFunction__getAlgorithmSize (castSXFunction x)


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


-- classy wrapper
sxFunction_getAtomicInputReal :: SXFunctionClass a => a -> Int -> IO Double
sxFunction_getAtomicInputReal x = casadi__SXFunction__getAtomicInputReal (castSXFunction x)


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


-- classy wrapper
sxFunction_getAtomicOperation :: SXFunctionClass a => a -> Int -> IO Int
sxFunction_getAtomicOperation x = casadi__SXFunction__getAtomicOperation (castSXFunction x)


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


-- classy wrapper
sxFunction_getAtomicOutput :: SXFunctionClass a => a -> Int -> IO Int
sxFunction_getAtomicOutput x = casadi__SXFunction__getAtomicOutput (castSXFunction x)


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


-- classy wrapper
sxFunction_getFree :: SXFunctionClass a => a -> IO (Vector SXElement)
sxFunction_getFree x = casadi__SXFunction__getFree (castSXFunction x)


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


-- classy wrapper
sxFunction_getWorkSize :: SXFunctionClass a => a -> IO Int
sxFunction_getWorkSize x = casadi__SXFunction__getWorkSize (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__0 :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_grad__0 x = casadi__SXFunction__grad__0 (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__1 :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_grad__1 x = casadi__SXFunction__grad__1 (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__2 :: SXFunctionClass a => a -> String -> IO SX
sxFunction_grad__2 x = casadi__SXFunction__grad__2 (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__3 :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_grad__3 x = casadi__SXFunction__grad__3 (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__4 :: SXFunctionClass a => a -> IO SX
sxFunction_grad__4 x = casadi__SXFunction__grad__4 (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__5 :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_grad__5 x = casadi__SXFunction__grad__5 (castSXFunction x)


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


-- classy wrapper
sxFunction_grad__6 :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_grad__6 x = casadi__SXFunction__grad__6 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__0 :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_hess__0 x = casadi__SXFunction__hess__0 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__1 :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_hess__1 x = casadi__SXFunction__hess__1 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__2 :: SXFunctionClass a => a -> String -> IO SX
sxFunction_hess__2 x = casadi__SXFunction__hess__2 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__3 :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_hess__3 x = casadi__SXFunction__hess__3 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__4 :: SXFunctionClass a => a -> IO SX
sxFunction_hess__4 x = casadi__SXFunction__hess__4 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__5 :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_hess__5 x = casadi__SXFunction__hess__5 (castSXFunction x)


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


-- classy wrapper
sxFunction_hess__6 :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_hess__6 x = casadi__SXFunction__hess__6 (castSXFunction x)


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


-- classy wrapper
sxFunction_inputExpr__0 :: SXFunctionClass a => a -> IO (Vector SX)
sxFunction_inputExpr__0 x = casadi__SXFunction__inputExpr__0 (castSXFunction x)


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


-- classy wrapper
sxFunction_inputExpr__1 :: SXFunctionClass a => a -> String -> IO SX
sxFunction_inputExpr__1 x = casadi__SXFunction__inputExpr__1 (castSXFunction x)


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


-- classy wrapper
sxFunction_inputExpr__2 :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_inputExpr__2 x = casadi__SXFunction__inputExpr__2 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__0 :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_jac__0 x = casadi__SXFunction__jac__0 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__1 :: SXFunctionClass a => a -> String -> String -> Bool -> IO SX
sxFunction_jac__1 x = casadi__SXFunction__jac__1 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__2 :: SXFunctionClass a => a -> String -> String -> Bool -> Bool -> IO SX
sxFunction_jac__2 x = casadi__SXFunction__jac__2 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__3 :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_jac__3 x = casadi__SXFunction__jac__3 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__4 :: SXFunctionClass a => a -> Int -> String -> Bool -> IO SX
sxFunction_jac__4 x = casadi__SXFunction__jac__4 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__5 :: SXFunctionClass a => a -> Int -> String -> Bool -> Bool -> IO SX
sxFunction_jac__5 x = casadi__SXFunction__jac__5 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__6 :: SXFunctionClass a => a -> String -> IO SX
sxFunction_jac__6 x = casadi__SXFunction__jac__6 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__7 :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_jac__7 x = casadi__SXFunction__jac__7 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__8 :: SXFunctionClass a => a -> String -> Int -> Bool -> IO SX
sxFunction_jac__8 x = casadi__SXFunction__jac__8 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__9 :: SXFunctionClass a => a -> String -> Int -> Bool -> Bool -> IO SX
sxFunction_jac__9 x = casadi__SXFunction__jac__9 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__10 :: SXFunctionClass a => a -> IO SX
sxFunction_jac__10 x = casadi__SXFunction__jac__10 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__11 :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_jac__11 x = casadi__SXFunction__jac__11 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__12 :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_jac__12 x = casadi__SXFunction__jac__12 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__13 :: SXFunctionClass a => a -> Int -> Int -> Bool -> IO SX
sxFunction_jac__13 x = casadi__SXFunction__jac__13 (castSXFunction x)


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


-- classy wrapper
sxFunction_jac__14 :: SXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO SX
sxFunction_jac__14 x = casadi__SXFunction__jac__14 (castSXFunction x)


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


-- classy wrapper
sxFunction_outputExpr__0 :: SXFunctionClass a => a -> IO (Vector SX)
sxFunction_outputExpr__0 x = casadi__SXFunction__outputExpr__0 (castSXFunction x)


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


-- classy wrapper
sxFunction_outputExpr__1 :: SXFunctionClass a => a -> String -> IO SX
sxFunction_outputExpr__1 x = casadi__SXFunction__outputExpr__1 (castSXFunction x)


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


-- classy wrapper
sxFunction_outputExpr__2 :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_outputExpr__2 x = casadi__SXFunction__outputExpr__2 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__0 :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_tang__0 x = casadi__SXFunction__tang__0 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__1 :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_tang__1 x = casadi__SXFunction__tang__1 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__2 :: SXFunctionClass a => a -> String -> IO SX
sxFunction_tang__2 x = casadi__SXFunction__tang__2 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__3 :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_tang__3 x = casadi__SXFunction__tang__3 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__4 :: SXFunctionClass a => a -> IO SX
sxFunction_tang__4 x = casadi__SXFunction__tang__4 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__5 :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_tang__5 x = casadi__SXFunction__tang__5 (castSXFunction x)


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


-- classy wrapper
sxFunction_tang__6 :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_tang__6 x = casadi__SXFunction__tang__6 (castSXFunction x)