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

module Casadi.Core.Classes.SymbolicOCP
       (
         SymbolicOCP,
         SymbolicOCPClass(..),
         symbolicOCP__0,
         symbolicOCP__1,
         symbolicOCP_addVariable,
         symbolicOCP_atTime__0,
         symbolicOCP_atTime__1,
         symbolicOCP_atTime__2,
         symbolicOCP_atTime__3,
         symbolicOCP_beq__0,
         symbolicOCP_beq__1,
         symbolicOCP_der__0,
         symbolicOCP_der__1,
         symbolicOCP_derivativeStart__0,
         symbolicOCP_derivativeStart__1,
         symbolicOCP_derivativeStart__2,
         symbolicOCP_derivativeStart__3,
         symbolicOCP_eliminateAlgebraic,
         symbolicOCP_eliminateDependentParameterInterdependencies,
         symbolicOCP_eliminateDependentParameters,
         symbolicOCP_eliminateIndependentParameters,
         symbolicOCP_eliminateLagrangeTerms,
         symbolicOCP_eliminateOutputInterdependencies,
         symbolicOCP_eliminateOutputs,
         symbolicOCP_eliminateQuadratureStates,
         symbolicOCP_generateMuscodDatFile,
         symbolicOCP_getDescription,
         symbolicOCP_getRepresentation,
         symbolicOCP_initialGuess__0,
         symbolicOCP_initialGuess__1,
         symbolicOCP_makeExplicit,
         symbolicOCP_makeSemiExplicit,
         symbolicOCP_max__0,
         symbolicOCP_max__1,
         symbolicOCP_min__0,
         symbolicOCP_min__1,
         symbolicOCP_nominal__0,
         symbolicOCP_nominal__1,
         symbolicOCP_ode__0,
         symbolicOCP_ode__1,
         symbolicOCP_parseFMI,
         symbolicOCP_scaleEquations,
         symbolicOCP_scaleVariables,
         symbolicOCP_separateAlgebraic,
         symbolicOCP_setBeq__0,
         symbolicOCP_setBeq__1,
         symbolicOCP_setDerivativeStart__0,
         symbolicOCP_setDerivativeStart__1,
         symbolicOCP_setDerivativeStart__2,
         symbolicOCP_setDerivativeStart__3,
         symbolicOCP_setInitialGuess__0,
         symbolicOCP_setInitialGuess__1,
         symbolicOCP_setMax__0,
         symbolicOCP_setMax__1,
         symbolicOCP_setMin__0,
         symbolicOCP_setMin__1,
         symbolicOCP_setNominal__0,
         symbolicOCP_setNominal__1,
         symbolicOCP_setOde__0,
         symbolicOCP_setOde__1,
         symbolicOCP_setStart__0,
         symbolicOCP_setStart__1,
         symbolicOCP_setStart__2,
         symbolicOCP_setStart__3,
         symbolicOCP_setUnit,
         symbolicOCP_sortALG,
         symbolicOCP_sortDAE,
         symbolicOCP_sortDependentParameters,
         symbolicOCP_sortOutputs,
         symbolicOCP_start__0,
         symbolicOCP_start__1,
         symbolicOCP_start__2,
         symbolicOCP_start__3,
         symbolicOCP_unit__0,
         symbolicOCP_unit__1,
         symbolicOCP_variable__0,
         symbolicOCP_variable__1,
       ) 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__SymbolicOCP__CONSTRUCTOR__0" c_casadi__SymbolicOCP__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> IO (Ptr SymbolicOCP')
casadi__SymbolicOCP__CONSTRUCTOR__0
  :: IO SymbolicOCP
casadi__SymbolicOCP__CONSTRUCTOR__0  =

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


-- classy wrapper
symbolicOCP__0 :: IO SymbolicOCP
symbolicOCP__0 = casadi__SymbolicOCP__CONSTRUCTOR__0


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


-- classy wrapper
symbolicOCP__1 :: Bool -> IO SymbolicOCP
symbolicOCP__1 = casadi__SymbolicOCP__CONSTRUCTOR__1


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


-- classy wrapper
symbolicOCP_addVariable :: SymbolicOCPClass a => a -> String -> Variable -> IO ()
symbolicOCP_addVariable x = casadi__SymbolicOCP__addVariable (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_atTime__0 :: SymbolicOCPClass a => a -> String -> Double -> IO SX
symbolicOCP_atTime__0 x = casadi__SymbolicOCP__atTime__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_atTime__1 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO SX
symbolicOCP_atTime__1 x = casadi__SymbolicOCP__atTime__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_atTime__2 :: SymbolicOCPClass a => a -> String -> Double -> IO SX
symbolicOCP_atTime__2 x = casadi__SymbolicOCP__atTime__2 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_atTime__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO SX
symbolicOCP_atTime__3 x = casadi__SymbolicOCP__atTime__3 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_beq__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_beq__0 x = casadi__SymbolicOCP__beq__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_beq__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_beq__1 x = casadi__SymbolicOCP__beq__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_der__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_der__0 x = casadi__SymbolicOCP__der__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_der__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_der__1 x = casadi__SymbolicOCP__der__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_derivativeStart__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_derivativeStart__0 x = casadi__SymbolicOCP__derivativeStart__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_derivativeStart__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_derivativeStart__1 x = casadi__SymbolicOCP__derivativeStart__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_derivativeStart__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_derivativeStart__2 x = casadi__SymbolicOCP__derivativeStart__2 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_derivativeStart__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_derivativeStart__3 x = casadi__SymbolicOCP__derivativeStart__3 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateAlgebraic :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateAlgebraic x = casadi__SymbolicOCP__eliminateAlgebraic (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateDependentParameterInterdependencies :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateDependentParameterInterdependencies x = casadi__SymbolicOCP__eliminateDependentParameterInterdependencies (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateDependentParameters :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateDependentParameters x = casadi__SymbolicOCP__eliminateDependentParameters (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateIndependentParameters :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateIndependentParameters x = casadi__SymbolicOCP__eliminateIndependentParameters (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateLagrangeTerms :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateLagrangeTerms x = casadi__SymbolicOCP__eliminateLagrangeTerms (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateOutputInterdependencies :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateOutputInterdependencies x = casadi__SymbolicOCP__eliminateOutputInterdependencies (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateOutputs :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateOutputs x = casadi__SymbolicOCP__eliminateOutputs (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_eliminateQuadratureStates :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateQuadratureStates x = casadi__SymbolicOCP__eliminateQuadratureStates (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_generateMuscodDatFile :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_generateMuscodDatFile x = casadi__SymbolicOCP__generateMuscodDatFile (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_initialGuess__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_initialGuess__0 x = casadi__SymbolicOCP__initialGuess__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_initialGuess__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_initialGuess__1 x = casadi__SymbolicOCP__initialGuess__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_makeExplicit :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_makeExplicit x = casadi__SymbolicOCP__makeExplicit (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_makeSemiExplicit :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_makeSemiExplicit x = casadi__SymbolicOCP__makeSemiExplicit (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_max__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_max__0 x = casadi__SymbolicOCP__max__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_max__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_max__1 x = casadi__SymbolicOCP__max__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_min__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_min__0 x = casadi__SymbolicOCP__min__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_min__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_min__1 x = casadi__SymbolicOCP__min__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_nominal__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_nominal__0 x = casadi__SymbolicOCP__nominal__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_nominal__1 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_nominal__1 x = casadi__SymbolicOCP__nominal__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_ode__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_ode__0 x = casadi__SymbolicOCP__ode__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_ode__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_ode__1 x = casadi__SymbolicOCP__ode__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_parseFMI :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_parseFMI x = casadi__SymbolicOCP__parseFMI (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_scaleEquations :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_scaleEquations x = casadi__SymbolicOCP__scaleEquations (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_scaleVariables :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_scaleVariables x = casadi__SymbolicOCP__scaleVariables (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_separateAlgebraic :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_separateAlgebraic x = casadi__SymbolicOCP__separateAlgebraic (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setBeq__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setBeq__0 x = casadi__SymbolicOCP__setBeq__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setBeq__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setBeq__1 x = casadi__SymbolicOCP__setBeq__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setDerivativeStart__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setDerivativeStart__0 x = casadi__SymbolicOCP__setDerivativeStart__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setDerivativeStart__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setDerivativeStart__1 x = casadi__SymbolicOCP__setDerivativeStart__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setDerivativeStart__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setDerivativeStart__2 x = casadi__SymbolicOCP__setDerivativeStart__2 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setDerivativeStart__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setDerivativeStart__3 x = casadi__SymbolicOCP__setDerivativeStart__3 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setInitialGuess__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setInitialGuess__0 x = casadi__SymbolicOCP__setInitialGuess__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setInitialGuess__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setInitialGuess__1 x = casadi__SymbolicOCP__setInitialGuess__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setMax__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setMax__0 x = casadi__SymbolicOCP__setMax__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setMax__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setMax__1 x = casadi__SymbolicOCP__setMax__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setMin__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setMin__0 x = casadi__SymbolicOCP__setMin__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setMin__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setMin__1 x = casadi__SymbolicOCP__setMin__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setNominal__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setNominal__0 x = casadi__SymbolicOCP__setNominal__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setNominal__1 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setNominal__1 x = casadi__SymbolicOCP__setNominal__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setOde__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setOde__0 x = casadi__SymbolicOCP__setOde__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setOde__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setOde__1 x = casadi__SymbolicOCP__setOde__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setStart__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setStart__0 x = casadi__SymbolicOCP__setStart__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setStart__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setStart__1 x = casadi__SymbolicOCP__setStart__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setStart__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setStart__2 x = casadi__SymbolicOCP__setStart__2 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setStart__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setStart__3 x = casadi__SymbolicOCP__setStart__3 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_setUnit :: SymbolicOCPClass a => a -> String -> String -> IO ()
symbolicOCP_setUnit x = casadi__SymbolicOCP__setUnit (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_sortALG :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortALG x = casadi__SymbolicOCP__sortALG (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_sortDAE :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortDAE x = casadi__SymbolicOCP__sortDAE (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_sortDependentParameters :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortDependentParameters x = casadi__SymbolicOCP__sortDependentParameters (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_sortOutputs :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortOutputs x = casadi__SymbolicOCP__sortOutputs (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_start__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_start__0 x = casadi__SymbolicOCP__start__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_start__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_start__1 x = casadi__SymbolicOCP__start__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_start__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_start__2 x = casadi__SymbolicOCP__start__2 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_start__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_start__3 x = casadi__SymbolicOCP__start__3 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_unit__0 :: SymbolicOCPClass a => a -> SX -> IO String
symbolicOCP_unit__0 x = casadi__SymbolicOCP__unit__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_unit__1 :: SymbolicOCPClass a => a -> String -> IO String
symbolicOCP_unit__1 x = casadi__SymbolicOCP__unit__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_variable__0 :: SymbolicOCPClass a => a -> String -> IO Variable
symbolicOCP_variable__0 x = casadi__SymbolicOCP__variable__0 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_variable__1 :: SymbolicOCPClass a => a -> String -> IO Variable
symbolicOCP_variable__1 x = casadi__SymbolicOCP__variable__1 (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_getRepresentation :: SymbolicOCPClass a => a -> IO String
symbolicOCP_getRepresentation x = casadi__SymbolicOCP__getRepresentation (castSymbolicOCP x)


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


-- classy wrapper
symbolicOCP_getDescription :: SymbolicOCPClass a => a -> IO String
symbolicOCP_getDescription x = casadi__SymbolicOCP__getDescription (castSymbolicOCP x)