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

module Casadi.Core.Classes.IOInterfaceFunction
       (
         IOInterfaceFunction,
         IOInterfaceFunctionClass(..),
         ioInterfaceFunction_getInputScheme,
         ioInterfaceFunction_getInput__0,
         ioInterfaceFunction_getInput__1,
         ioInterfaceFunction_getInput__2,
         ioInterfaceFunction_getNumInputs,
         ioInterfaceFunction_getNumOutputs,
         ioInterfaceFunction_getOutputScheme,
         ioInterfaceFunction_getOutput__0,
         ioInterfaceFunction_getOutput__1,
         ioInterfaceFunction_getOutput__2,
         ioInterfaceFunction_inputSchemeEntry,
         ioInterfaceFunction_input__0,
         ioInterfaceFunction_input__1,
         ioInterfaceFunction_input__2,
         ioInterfaceFunction_input__3,
         ioInterfaceFunction_input__4,
         ioInterfaceFunction_input__5,
         ioInterfaceFunction_outputSchemeEntry,
         ioInterfaceFunction_output__0,
         ioInterfaceFunction_output__1,
         ioInterfaceFunction_output__2,
         ioInterfaceFunction_output__3,
         ioInterfaceFunction_output__4,
         ioInterfaceFunction_output__5,
         ioInterfaceFunction_schemeEntry,
         ioInterfaceFunction_setInputScheme,
         ioInterfaceFunction_setInput__0,
         ioInterfaceFunction_setInput__1,
         ioInterfaceFunction_setInput__2,
         ioInterfaceFunction_setInput__3,
         ioInterfaceFunction_setInput__4,
         ioInterfaceFunction_setInput__5,
         ioInterfaceFunction_setInput__6,
         ioInterfaceFunction_setInput__7,
         ioInterfaceFunction_setInput__8,
         ioInterfaceFunction_setNumInputs,
         ioInterfaceFunction_setNumOutputs,
         ioInterfaceFunction_setOutputScheme,
         ioInterfaceFunction_setOutput__0,
         ioInterfaceFunction_setOutput__1,
         ioInterfaceFunction_setOutput__2,
         ioInterfaceFunction_setOutput__3,
         ioInterfaceFunction_setOutput__4,
         ioInterfaceFunction_setOutput__5,
         ioInterfaceFunction_setOutput__6,
         ioInterfaceFunction_setOutput__7,
         ioInterfaceFunction_setOutput__8,
       ) 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__IOInterface_casadi__Function___getInput__0" c_casadi__IOInterface_casadi__Function___getInput__0
  :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix')
casadi__IOInterface_casadi__Function___getInput__0
  :: IOInterfaceFunction -> String -> IO DMatrix
casadi__IOInterface_casadi__Function___getInput__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__IOInterface_casadi__Function___getInput__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
ioInterfaceFunction_getInput__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_getInput__0 x = casadi__IOInterface_casadi__Function___getInput__0 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getInput__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_getInput__1 x = casadi__IOInterface_casadi__Function___getInput__1 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getInput__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_getInput__2 x = casadi__IOInterface_casadi__Function___getInput__2 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getInputScheme :: IOInterfaceFunctionClass a => a -> IO IOScheme
ioInterfaceFunction_getInputScheme x = casadi__IOInterface_casadi__Function___getInputScheme (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getNumInputs :: IOInterfaceFunctionClass a => a -> IO Int
ioInterfaceFunction_getNumInputs x = casadi__IOInterface_casadi__Function___getNumInputs (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getNumOutputs :: IOInterfaceFunctionClass a => a -> IO Int
ioInterfaceFunction_getNumOutputs x = casadi__IOInterface_casadi__Function___getNumOutputs (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getOutput__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_getOutput__0 x = casadi__IOInterface_casadi__Function___getOutput__0 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getOutput__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_getOutput__1 x = casadi__IOInterface_casadi__Function___getOutput__1 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getOutput__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_getOutput__2 x = casadi__IOInterface_casadi__Function___getOutput__2 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_getOutputScheme :: IOInterfaceFunctionClass a => a -> IO IOScheme
ioInterfaceFunction_getOutputScheme x = casadi__IOInterface_casadi__Function___getOutputScheme (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_input__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_input__0 x = casadi__IOInterface_casadi__Function___input__0 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_input__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_input__1 x = casadi__IOInterface_casadi__Function___input__1 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_input__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_input__2 x = casadi__IOInterface_casadi__Function___input__2 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_input__3 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_input__3 x = casadi__IOInterface_casadi__Function___input__3 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_input__4 :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_input__4 x = casadi__IOInterface_casadi__Function___input__4 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_input__5 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_input__5 x = casadi__IOInterface_casadi__Function___input__5 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_inputSchemeEntry :: IOInterfaceFunctionClass a => a -> String -> IO Int
ioInterfaceFunction_inputSchemeEntry x = casadi__IOInterface_casadi__Function___inputSchemeEntry (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_output__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_output__0 x = casadi__IOInterface_casadi__Function___output__0 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_output__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_output__1 x = casadi__IOInterface_casadi__Function___output__1 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_output__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_output__2 x = casadi__IOInterface_casadi__Function___output__2 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_output__3 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix
ioInterfaceFunction_output__3 x = casadi__IOInterface_casadi__Function___output__3 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_output__4 :: IOInterfaceFunctionClass a => a -> IO DMatrix
ioInterfaceFunction_output__4 x = casadi__IOInterface_casadi__Function___output__4 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_output__5 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix
ioInterfaceFunction_output__5 x = casadi__IOInterface_casadi__Function___output__5 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_outputSchemeEntry :: IOInterfaceFunctionClass a => a -> String -> IO Int
ioInterfaceFunction_outputSchemeEntry x = casadi__IOInterface_casadi__Function___outputSchemeEntry (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_schemeEntry :: IOInterfaceFunctionClass a => a -> IOScheme -> String -> Bool -> IO Int
ioInterfaceFunction_schemeEntry x = casadi__IOInterface_casadi__Function___schemeEntry (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
ioInterfaceFunction_setInput__0 x = casadi__IOInterface_casadi__Function___setInput__0 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
ioInterfaceFunction_setInput__1 x = casadi__IOInterface_casadi__Function___setInput__1 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
ioInterfaceFunction_setInput__2 x = casadi__IOInterface_casadi__Function___setInput__2 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__3 :: IOInterfaceFunctionClass a => a -> Vector Double -> String -> IO ()
ioInterfaceFunction_setInput__3 x = casadi__IOInterface_casadi__Function___setInput__3 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__4 :: IOInterfaceFunctionClass a => a -> Vector Double -> IO ()
ioInterfaceFunction_setInput__4 x = casadi__IOInterface_casadi__Function___setInput__4 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__5 :: IOInterfaceFunctionClass a => a -> Vector Double -> Int -> IO ()
ioInterfaceFunction_setInput__5 x = casadi__IOInterface_casadi__Function___setInput__5 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__6 :: IOInterfaceFunctionClass a => a -> Double -> String -> IO ()
ioInterfaceFunction_setInput__6 x = casadi__IOInterface_casadi__Function___setInput__6 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__7 :: IOInterfaceFunctionClass a => a -> Double -> IO ()
ioInterfaceFunction_setInput__7 x = casadi__IOInterface_casadi__Function___setInput__7 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInput__8 :: IOInterfaceFunctionClass a => a -> Double -> Int -> IO ()
ioInterfaceFunction_setInput__8 x = casadi__IOInterface_casadi__Function___setInput__8 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setInputScheme :: IOInterfaceFunctionClass a => a -> IOScheme -> IO ()
ioInterfaceFunction_setInputScheme x = casadi__IOInterface_casadi__Function___setInputScheme (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setNumInputs :: IOInterfaceFunctionClass a => a -> Int -> IO ()
ioInterfaceFunction_setNumInputs x = casadi__IOInterface_casadi__Function___setNumInputs (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setNumOutputs :: IOInterfaceFunctionClass a => a -> Int -> IO ()
ioInterfaceFunction_setNumOutputs x = casadi__IOInterface_casadi__Function___setNumOutputs (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO ()
ioInterfaceFunction_setOutput__0 x = casadi__IOInterface_casadi__Function___setOutput__0 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO ()
ioInterfaceFunction_setOutput__1 x = casadi__IOInterface_casadi__Function___setOutput__1 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO ()
ioInterfaceFunction_setOutput__2 x = casadi__IOInterface_casadi__Function___setOutput__2 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__3 :: IOInterfaceFunctionClass a => a -> Vector Double -> String -> IO ()
ioInterfaceFunction_setOutput__3 x = casadi__IOInterface_casadi__Function___setOutput__3 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__4 :: IOInterfaceFunctionClass a => a -> Vector Double -> IO ()
ioInterfaceFunction_setOutput__4 x = casadi__IOInterface_casadi__Function___setOutput__4 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__5 :: IOInterfaceFunctionClass a => a -> Vector Double -> Int -> IO ()
ioInterfaceFunction_setOutput__5 x = casadi__IOInterface_casadi__Function___setOutput__5 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__6 :: IOInterfaceFunctionClass a => a -> Double -> String -> IO ()
ioInterfaceFunction_setOutput__6 x = casadi__IOInterface_casadi__Function___setOutput__6 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__7 :: IOInterfaceFunctionClass a => a -> Double -> IO ()
ioInterfaceFunction_setOutput__7 x = casadi__IOInterface_casadi__Function___setOutput__7 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutput__8 :: IOInterfaceFunctionClass a => a -> Double -> Int -> IO ()
ioInterfaceFunction_setOutput__8 x = casadi__IOInterface_casadi__Function___setOutput__8 (castIOInterfaceFunction x)


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


-- classy wrapper
ioInterfaceFunction_setOutputScheme :: IOInterfaceFunctionClass a => a -> IOScheme -> IO ()
ioInterfaceFunction_setOutputScheme x = casadi__IOInterface_casadi__Function___setOutputScheme (castIOInterfaceFunction x)