casadi-bindings-core-2.1.0.0: Casadi/Core/Classes/SX.hs

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

module Casadi.Core.Classes.SX
       (
         SX,
         SXClass(..),
         sx__0,
         sx__1,
         sx__10,
         sx__11,
         sx__12,
         sx__13,
         sx__14,
         sx__2,
         sx__3,
         sx__4,
         sx__5,
         sx__6,
         sx__7,
         sx__8,
         sx__9,
         sx___add__,
         sx___constpow__,
         sx___copysign__,
         sx___div__,
         sx___eq__,
         sx___ge____0,
         sx___ge____1,
         sx___gt____0,
         sx___gt____1,
         sx___le__,
         sx___lt__,
         sx___mldivide__,
         sx___mpower__,
         sx___mrdivide__,
         sx___mul__,
         sx___ne__,
         sx___nonzero__,
         sx___pow__,
         sx___radd__,
         sx___rdiv__,
         sx___req__,
         sx___rge__,
         sx___rgt__,
         sx___rle__,
         sx___rlt__,
         sx___rmul__,
         sx___rne__,
         sx___rsub__,
         sx___rtruediv__,
         sx___sub__,
         sx___truediv____0,
         sx___truediv____1,
         sx_append,
         sx_appendColumns,
         sx_arccos,
         sx_arccosh,
         sx_arcsin,
         sx_arcsinh,
         sx_arctan,
         sx_arctan2,
         sx_arctanh,
         sx_at,
         sx_binary,
         sx_ceil,
         sx_className,
         sx_clear,
         sx_colind__0,
         sx_colind__1,
         sx_cos,
         sx_cosh,
         sx_data__0,
         sx_data__1,
         sx_densify__0,
         sx_densify__1,
         sx_dimString,
         sx_elem__0,
         sx_elem__1,
         sx_enlarge,
         sx_erase,
         sx_erf,
         sx_erfinv,
         sx_exp,
         sx_eye,
         sx_fabs,
         sx_floor,
         sx_fmax,
         sx_fmin,
         sx_fmod,
         sx_getElement__0,
         sx_getElement__1,
         sx_getEqualityCheckingDepth,
         sx_getMaxNumCallsInPrint,
         sx_getNZ__0,
         sx_getNZ__1,
         sx_getNZ__2,
         sx_getNZ__3,
         sx_getName,
         sx_getValue,
         sx_get__0,
         sx_get__1,
         sx_get__2,
         sx_get__3,
         sx_get__4,
         sx_get__5,
         sx_hasNZ,
         sx_hasNonStructuralZeros,
         sx_if_else_zero,
         sx_indexed__0,
         sx_indexed__1,
         sx_indexed__2,
         sx_indexed__3,
         sx_indexed__4,
         sx_indexed__5,
         sx_indexed_assignment__0,
         sx_indexed_assignment__1,
         sx_indexed_assignment__2,
         sx_indexed_assignment__3,
         sx_indexed_assignment__4,
         sx_indexed_assignment__5,
         sx_indexed_one_based__0,
         sx_indexed_one_based__1,
         sx_indexed_one_based__2,
         sx_indexed_one_based_assignment__0,
         sx_indexed_one_based_assignment__1,
         sx_indexed_one_based_assignment__2,
         sx_indexed_zero_based__0,
         sx_indexed_zero_based__1,
         sx_indexed_zero_based__2,
         sx_indexed_zero_based_assignment__0,
         sx_indexed_zero_based_assignment__1,
         sx_indexed_zero_based_assignment__2,
         sx_inf__0,
         sx_inf__1,
         sx_inf__2,
         sx_inf__3,
         sx_isConstant,
         sx_isDense,
         sx_isEmpty__0,
         sx_isEmpty__1,
         sx_isEqual,
         sx_isIdentity,
         sx_isInteger,
         sx_isMinusOne,
         sx_isOne,
         sx_isRegular,
         sx_isScalar__0,
         sx_isScalar__1,
         sx_isSmooth,
         sx_isSquare,
         sx_isSymbolic,
         sx_isSymbolicSparse,
         sx_isTril,
         sx_isTriu,
         sx_isVector,
         sx_isZero,
         sx_log,
         sx_log10,
         sx_logic_and,
         sx_logic_not,
         sx_logic_or,
         sx_matrix_matrix,
         sx_matrix_scalar,
         sx_mul__0,
         sx_mul__1,
         sx_mul_full__0,
         sx_mul_full__1,
         sx_mul_no_alloc_nn__0,
         sx_mul_no_alloc_nn__1,
         sx_mul_no_alloc_nn__2,
         sx_mul_no_alloc_nt,
         sx_mul_no_alloc_tn__0,
         sx_mul_no_alloc_tn__1,
         sx_mul_smart,
         sx_nan__0,
         sx_nan__1,
         sx_nan__2,
         sx_nan__3,
         sx_numel,
         sx_nz_indexed,
         sx_nz_indexed_assignment,
         sx_nz_indexed_one_based__0,
         sx_nz_indexed_one_based__1,
         sx_nz_indexed_one_based_assignment__0,
         sx_nz_indexed_one_based_assignment__1,
         sx_nz_indexed_zero_based__0,
         sx_nz_indexed_zero_based__1,
         sx_nz_indexed_zero_based_assignment__0,
         sx_nz_indexed_zero_based_assignment__1,
         sx_ones__0,
         sx_ones__1,
         sx_ones__2,
         sx_ones__3,
         sx_printDense,
         sx_printScalar,
         sx_printSparse,
         sx_printVector,
         sx_printme,
         sx_quad_form,
         sx_remove,
         sx_repmat__0,
         sx_repmat__1,
         sx_repmat__2,
         sx_repmat__3,
         sx_reserve__0,
         sx_reserve__1,
         sx_resize,
         sx_row__0,
         sx_row__1,
         sx_sanityCheck__0,
         sx_sanityCheck__1,
         sx_scalar_matrix,
         sx_setAll,
         sx_setEqualityCheckingDepth__0,
         sx_setEqualityCheckingDepth__1,
         sx_setMaxNumCallsInPrint__0,
         sx_setMaxNumCallsInPrint__1,
         sx_setNZ__0,
         sx_setNZ__1,
         sx_setNZ__2,
         sx_setNZ__3,
         sx_setPrecision,
         sx_setScientific,
         sx_setSparse__0,
         sx_setSparse__1,
         sx_setSub__0,
         sx_setSub__1,
         sx_setSub__10,
         sx_setSub__11,
         sx_setSub__12,
         sx_setSub__13,
         sx_setSub__14,
         sx_setSub__15,
         sx_setSub__16,
         sx_setSub__2,
         sx_setSub__3,
         sx_setSub__4,
         sx_setSub__5,
         sx_setSub__6,
         sx_setSub__7,
         sx_setSub__8,
         sx_setSub__9,
         sx_setWidth,
         sx_setZero,
         sx_set__0,
         sx_set__1,
         sx_set__2,
         sx_set__3,
         sx_set__4,
         sx_set__5,
         sx_sign,
         sx_sin,
         sx_sinh,
         sx_size1,
         sx_size2,
         sx_sizeD,
         sx_sizeL,
         sx_sizeU,
         sx_size__0,
         sx_size__1,
         sx_sparse__0,
         sx_sparse__1,
         sx_sparse__2,
         sx_sparsify__0,
         sx_sparsify__1,
         sx_sparsityRef__0,
         sx_sparsityRef__1,
         sx_sparsity__0,
         sx_sparsity__1,
         sx_sqrt,
         sx_sub__0,
         sx_sub__1,
         sx_sub__10,
         sx_sub__11,
         sx_sub__12,
         sx_sub__13,
         sx_sub__14,
         sx_sub__15,
         sx_sub__16,
         sx_sub__17,
         sx_sub__2,
         sx_sub__3,
         sx_sub__4,
         sx_sub__5,
         sx_sub__6,
         sx_sub__7,
         sx_sub__8,
         sx_sub__9,
         sx_sym__0,
         sx_sym__1,
         sx_sym__2,
         sx_sym__3,
         sx_sym__4,
         sx_sym__5,
         sx_sym__6,
         sx_sym__7,
         sx_tan,
         sx_tanh,
         sx_toScalar,
         sx_trans,
         sx_triplet__0,
         sx_triplet__1,
         sx_unary,
         sx_zeros__0,
         sx_zeros__1,
         sx_zeros__2,
         sx_zeros__3,
       ) 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__SX__CONSTRUCTOR__0" c_casadi__SX__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> CInt -> CInt -> IO (Ptr SX')
casadi__SX__CONSTRUCTOR__0
  :: Vector Double -> Int -> Int -> IO SX
casadi__SX__CONSTRUCTOR__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SX__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sx__0 :: Vector Double -> Int -> Int -> IO SX
sx__0 = casadi__SX__CONSTRUCTOR__0


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


-- classy wrapper
sx__1 :: Vector Double -> IO SX
sx__1 = casadi__SX__CONSTRUCTOR__1


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


-- classy wrapper
sx__2 :: DMatrix -> IO SX
sx__2 = casadi__SX__CONSTRUCTOR__2


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


-- classy wrapper
sx__3 :: Vector Int -> Int -> Int -> IO SX
sx__3 = casadi__SX__CONSTRUCTOR__3


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


-- classy wrapper
sx__4 :: Vector Int -> IO SX
sx__4 = casadi__SX__CONSTRUCTOR__4


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


-- classy wrapper
sx__5 :: IMatrix -> IO SX
sx__5 = casadi__SX__CONSTRUCTOR__5


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


-- classy wrapper
sx__6 :: Vector SXElement -> Int -> Int -> IO SX
sx__6 = casadi__SX__CONSTRUCTOR__6


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


-- classy wrapper
sx__7 :: Vector SXElement -> IO SX
sx__7 = casadi__SX__CONSTRUCTOR__7


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


-- classy wrapper
sx__8 :: Double -> IO SX
sx__8 = casadi__SX__CONSTRUCTOR__8


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


-- classy wrapper
sx__9 :: Sparsity -> Vector SXElement -> IO SX
sx__9 = casadi__SX__CONSTRUCTOR__9


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


-- classy wrapper
sx__10 :: Sparsity -> IO SX
sx__10 = casadi__SX__CONSTRUCTOR__10


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


-- classy wrapper
sx__11 :: Sparsity -> SXElement -> IO SX
sx__11 = casadi__SX__CONSTRUCTOR__11


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


-- classy wrapper
sx__12 :: Vector (Vector SXElement) -> IO SX
sx__12 = casadi__SX__CONSTRUCTOR__12


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


-- classy wrapper
sx__13 :: SX -> IO SX
sx__13 = casadi__SX__CONSTRUCTOR__13


-- direct wrapper
foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__14" c_casadi__SX__CONSTRUCTOR__14
  :: Ptr (Ptr StdString) -> IO (Ptr SX')
casadi__SX__CONSTRUCTOR__14
  :: IO SX
casadi__SX__CONSTRUCTOR__14  =

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


-- classy wrapper
sx__14 :: IO SX
sx__14 = casadi__SX__CONSTRUCTOR__14


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


-- classy wrapper
sx___add__ :: SXClass a => a -> SX -> IO SX
sx___add__ x = casadi__SX____add__ (castSX x)


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


-- classy wrapper
sx___constpow__ :: SXClass a => a -> SX -> IO SX
sx___constpow__ x = casadi__SX____constpow__ (castSX x)


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


-- classy wrapper
sx___copysign__ :: SXClass a => a -> SX -> IO SX
sx___copysign__ x = casadi__SX____copysign__ (castSX x)


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


-- classy wrapper
sx___div__ :: SXClass a => a -> SX -> IO SX
sx___div__ x = casadi__SX____div__ (castSX x)


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


-- classy wrapper
sx___eq__ :: SXClass a => a -> SX -> IO SX
sx___eq__ x = casadi__SX____eq__ (castSX x)


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


-- classy wrapper
sx___ge____0 :: SXClass a => a -> SX -> IO SX
sx___ge____0 x = casadi__SX____ge____0 (castSX x)


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


-- classy wrapper
sx___ge____1 :: SXClass a => a -> SX -> IO SX
sx___ge____1 x = casadi__SX____ge____1 (castSX x)


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


-- classy wrapper
sx___gt____0 :: SXClass a => a -> SX -> IO SX
sx___gt____0 x = casadi__SX____gt____0 (castSX x)


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


-- classy wrapper
sx___gt____1 :: SXClass a => a -> SX -> IO SX
sx___gt____1 x = casadi__SX____gt____1 (castSX x)


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


-- classy wrapper
sx___le__ :: SXClass a => a -> SX -> IO SX
sx___le__ x = casadi__SX____le__ (castSX x)


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


-- classy wrapper
sx___lt__ :: SXClass a => a -> SX -> IO SX
sx___lt__ x = casadi__SX____lt__ (castSX x)


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


-- classy wrapper
sx___mldivide__ :: SXClass a => a -> SX -> IO SX
sx___mldivide__ x = casadi__SX____mldivide__ (castSX x)


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


-- classy wrapper
sx___mpower__ :: SXClass a => a -> SX -> IO SX
sx___mpower__ x = casadi__SX____mpower__ (castSX x)


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


-- classy wrapper
sx___mrdivide__ :: SXClass a => a -> SX -> IO SX
sx___mrdivide__ x = casadi__SX____mrdivide__ (castSX x)


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


-- classy wrapper
sx___mul__ :: SXClass a => a -> SX -> IO SX
sx___mul__ x = casadi__SX____mul__ (castSX x)


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


-- classy wrapper
sx___ne__ :: SXClass a => a -> SX -> IO SX
sx___ne__ x = casadi__SX____ne__ (castSX x)


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


-- classy wrapper
sx___nonzero__ :: SXClass a => a -> IO Bool
sx___nonzero__ x = casadi__SX____nonzero__ (castSX x)


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


-- classy wrapper
sx___pow__ :: SXClass a => a -> SX -> IO SX
sx___pow__ x = casadi__SX____pow__ (castSX x)


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


-- classy wrapper
sx___radd__ :: SXClass a => a -> SX -> IO SX
sx___radd__ x = casadi__SX____radd__ (castSX x)


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


-- classy wrapper
sx___rdiv__ :: SXClass a => a -> SX -> IO SX
sx___rdiv__ x = casadi__SX____rdiv__ (castSX x)


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


-- classy wrapper
sx___req__ :: SXClass a => a -> SX -> IO SX
sx___req__ x = casadi__SX____req__ (castSX x)


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


-- classy wrapper
sx___rge__ :: SXClass a => a -> SX -> IO SX
sx___rge__ x = casadi__SX____rge__ (castSX x)


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


-- classy wrapper
sx___rgt__ :: SXClass a => a -> SX -> IO SX
sx___rgt__ x = casadi__SX____rgt__ (castSX x)


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


-- classy wrapper
sx___rle__ :: SXClass a => a -> SX -> IO SX
sx___rle__ x = casadi__SX____rle__ (castSX x)


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


-- classy wrapper
sx___rlt__ :: SXClass a => a -> SX -> IO SX
sx___rlt__ x = casadi__SX____rlt__ (castSX x)


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


-- classy wrapper
sx___rmul__ :: SXClass a => a -> SX -> IO SX
sx___rmul__ x = casadi__SX____rmul__ (castSX x)


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


-- classy wrapper
sx___rne__ :: SXClass a => a -> SX -> IO SX
sx___rne__ x = casadi__SX____rne__ (castSX x)


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


-- classy wrapper
sx___rsub__ :: SXClass a => a -> SX -> IO SX
sx___rsub__ x = casadi__SX____rsub__ (castSX x)


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


-- classy wrapper
sx___rtruediv__ :: SXClass a => a -> SX -> IO SX
sx___rtruediv__ x = casadi__SX____rtruediv__ (castSX x)


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


-- classy wrapper
sx___sub__ :: SXClass a => a -> SX -> IO SX
sx___sub__ x = casadi__SX____sub__ (castSX x)


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


-- classy wrapper
sx___truediv____0 :: SXClass a => a -> SX -> IO SX
sx___truediv____0 x = casadi__SX____truediv____0 (castSX x)


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


-- classy wrapper
sx___truediv____1 :: SXClass a => a -> SX -> IO SX
sx___truediv____1 x = casadi__SX____truediv____1 (castSX x)


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


-- classy wrapper
sx_append :: SXClass a => a -> SX -> IO ()
sx_append x = casadi__SX__append (castSX x)


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


-- classy wrapper
sx_appendColumns :: SXClass a => a -> SX -> IO ()
sx_appendColumns x = casadi__SX__appendColumns (castSX x)


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


-- classy wrapper
sx_arccos :: SXClass a => a -> IO SX
sx_arccos x = casadi__SX__arccos (castSX x)


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


-- classy wrapper
sx_arccosh :: SXClass a => a -> IO SX
sx_arccosh x = casadi__SX__arccosh (castSX x)


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


-- classy wrapper
sx_arcsin :: SXClass a => a -> IO SX
sx_arcsin x = casadi__SX__arcsin (castSX x)


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


-- classy wrapper
sx_arcsinh :: SXClass a => a -> IO SX
sx_arcsinh x = casadi__SX__arcsinh (castSX x)


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


-- classy wrapper
sx_arctan :: SXClass a => a -> IO SX
sx_arctan x = casadi__SX__arctan (castSX x)


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


-- classy wrapper
sx_arctan2 :: SXClass a => a -> SX -> IO SX
sx_arctan2 x = casadi__SX__arctan2 (castSX x)


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


-- classy wrapper
sx_arctanh :: SXClass a => a -> IO SX
sx_arctanh x = casadi__SX__arctanh (castSX x)


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


-- classy wrapper
sx_at :: SXClass a => a -> Int -> IO SXElement
sx_at x = casadi__SX__at (castSX x)


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


-- classy wrapper
sx_binary :: Int -> SX -> SX -> IO SX
sx_binary = casadi__SX__binary


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


-- classy wrapper
sx_ceil :: SXClass a => a -> IO SX
sx_ceil x = casadi__SX__ceil (castSX x)


-- direct wrapper
foreign import ccall unsafe "casadi__SX__className" c_casadi__SX__className
  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
casadi__SX__className
  :: IO String
casadi__SX__className  =

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


-- classy wrapper
sx_className :: IO String
sx_className = casadi__SX__className


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


-- classy wrapper
sx_clear :: SXClass a => a -> IO ()
sx_clear x = casadi__SX__clear (castSX x)


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


-- classy wrapper
sx_colind__0 :: SXClass a => a -> Int -> IO Int
sx_colind__0 x = casadi__SX__colind__0 (castSX x)


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


-- classy wrapper
sx_colind__1 :: SXClass a => a -> IO (Vector Int)
sx_colind__1 x = casadi__SX__colind__1 (castSX x)


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


-- classy wrapper
sx_cos :: SXClass a => a -> IO SX
sx_cos x = casadi__SX__cos (castSX x)


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


-- classy wrapper
sx_cosh :: SXClass a => a -> IO SX
sx_cosh x = casadi__SX__cosh (castSX x)


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


-- classy wrapper
sx_data__0 :: SXClass a => a -> IO (Vector SXElement)
sx_data__0 x = casadi__SX__data__0 (castSX x)


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


-- classy wrapper
sx_data__1 :: SXClass a => a -> IO (Vector SXElement)
sx_data__1 x = casadi__SX__data__1 (castSX x)


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


-- classy wrapper
sx_densify__0 :: SXClass a => a -> IO ()
sx_densify__0 x = casadi__SX__densify__0 (castSX x)


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


-- classy wrapper
sx_densify__1 :: SXClass a => a -> SXElement -> IO ()
sx_densify__1 x = casadi__SX__densify__1 (castSX x)


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


-- classy wrapper
sx_dimString :: SXClass a => a -> IO String
sx_dimString x = casadi__SX__dimString (castSX x)


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


-- classy wrapper
sx_elem__0 :: SXClass a => a -> Int -> IO SXElement
sx_elem__0 x = casadi__SX__elem__0 (castSX x)


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


-- classy wrapper
sx_elem__1 :: SXClass a => a -> Int -> Int -> IO SXElement
sx_elem__1 x = casadi__SX__elem__1 (castSX x)


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


-- classy wrapper
sx_enlarge :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
sx_enlarge x = casadi__SX__enlarge (castSX x)


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


-- classy wrapper
sx_erase :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
sx_erase x = casadi__SX__erase (castSX x)


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


-- classy wrapper
sx_erf :: SXClass a => a -> IO SX
sx_erf x = casadi__SX__erf (castSX x)


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


-- classy wrapper
sx_erfinv :: SXClass a => a -> IO SX
sx_erfinv x = casadi__SX__erfinv (castSX x)


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


-- classy wrapper
sx_exp :: SXClass a => a -> IO SX
sx_exp x = casadi__SX__exp (castSX x)


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


-- classy wrapper
sx_eye :: Int -> IO SX
sx_eye = casadi__SX__eye


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


-- classy wrapper
sx_fabs :: SXClass a => a -> IO SX
sx_fabs x = casadi__SX__fabs (castSX x)


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


-- classy wrapper
sx_floor :: SXClass a => a -> IO SX
sx_floor x = casadi__SX__floor (castSX x)


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


-- classy wrapper
sx_fmax :: SXClass a => a -> SX -> IO SX
sx_fmax x = casadi__SX__fmax (castSX x)


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


-- classy wrapper
sx_fmin :: SXClass a => a -> SX -> IO SX
sx_fmin x = casadi__SX__fmin (castSX x)


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


-- classy wrapper
sx_fmod :: SXClass a => a -> SX -> IO SX
sx_fmod x = casadi__SX__fmod (castSX x)


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


-- classy wrapper
sx_get__0 :: SXClass a => a -> SX -> IO ()
sx_get__0 x = casadi__SX__get__0 (castSX x)


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


-- classy wrapper
sx_get__1 :: SXClass a => a -> SX -> SparsityType -> IO ()
sx_get__1 x = casadi__SX__get__1 (castSX x)


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


-- classy wrapper
sx_get__2 :: SXClass a => a -> Vector SXElement -> IO ()
sx_get__2 x = casadi__SX__get__2 (castSX x)


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


-- classy wrapper
sx_get__3 :: SXClass a => a -> Vector SXElement -> SparsityType -> IO ()
sx_get__3 x = casadi__SX__get__3 (castSX x)


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


-- classy wrapper
sx_get__4 :: SXClass a => a -> SXElement -> IO ()
sx_get__4 x = casadi__SX__get__4 (castSX x)


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


-- classy wrapper
sx_get__5 :: SXClass a => a -> SXElement -> SparsityType -> IO ()
sx_get__5 x = casadi__SX__get__5 (castSX x)


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


-- classy wrapper
sx_getElement__0 :: SXClass a => a -> Int -> IO SXElement
sx_getElement__0 x = casadi__SX__getElement__0 (castSX x)


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


-- classy wrapper
sx_getElement__1 :: SXClass a => a -> Int -> Int -> IO SXElement
sx_getElement__1 x = casadi__SX__getElement__1 (castSX x)


-- direct wrapper
foreign import ccall unsafe "casadi__SX__getEqualityCheckingDepth" c_casadi__SX__getEqualityCheckingDepth
  :: Ptr (Ptr StdString) -> IO CInt
casadi__SX__getEqualityCheckingDepth
  :: IO Int
casadi__SX__getEqualityCheckingDepth  =

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


-- classy wrapper
sx_getEqualityCheckingDepth :: IO Int
sx_getEqualityCheckingDepth = casadi__SX__getEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "casadi__SX__getMaxNumCallsInPrint" c_casadi__SX__getMaxNumCallsInPrint
  :: Ptr (Ptr StdString) -> IO CLong
casadi__SX__getMaxNumCallsInPrint
  :: IO Int
casadi__SX__getMaxNumCallsInPrint  =

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


-- classy wrapper
sx_getMaxNumCallsInPrint :: IO Int
sx_getMaxNumCallsInPrint = casadi__SX__getMaxNumCallsInPrint


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


-- classy wrapper
sx_getNZ__0 :: SXClass a => a -> IMatrix -> IO SX
sx_getNZ__0 x = casadi__SX__getNZ__0 (castSX x)


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


-- classy wrapper
sx_getNZ__1 :: SXClass a => a -> Slice -> IO SX
sx_getNZ__1 x = casadi__SX__getNZ__1 (castSX x)


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


-- classy wrapper
sx_getNZ__2 :: SXClass a => a -> Vector Int -> IO SX
sx_getNZ__2 x = casadi__SX__getNZ__2 (castSX x)


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


-- classy wrapper
sx_getNZ__3 :: SXClass a => a -> Int -> IO SX
sx_getNZ__3 x = casadi__SX__getNZ__3 (castSX x)


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


-- classy wrapper
sx_getName :: SXClass a => a -> IO String
sx_getName x = casadi__SX__getName (castSX x)


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


-- classy wrapper
sx_getValue :: SXClass a => a -> IO Double
sx_getValue x = casadi__SX__getValue (castSX x)


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


-- classy wrapper
sx_hasNZ :: SXClass a => a -> Int -> Int -> IO Bool
sx_hasNZ x = casadi__SX__hasNZ (castSX x)


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


-- classy wrapper
sx_hasNonStructuralZeros :: SXClass a => a -> IO Bool
sx_hasNonStructuralZeros x = casadi__SX__hasNonStructuralZeros (castSX x)


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


-- classy wrapper
sx_if_else_zero :: SXClass a => a -> SX -> IO SX
sx_if_else_zero x = casadi__SX__if_else_zero (castSX x)


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


-- classy wrapper
sx_indexed__0 :: SXClass a => a -> Slice -> IO SX
sx_indexed__0 x = casadi__SX__indexed__0 (castSX x)


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


-- classy wrapper
sx_indexed__1 :: SXClass a => a -> Sparsity -> IO SX
sx_indexed__1 x = casadi__SX__indexed__1 (castSX x)


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


-- classy wrapper
sx_indexed__2 :: SXClass a => a -> IMatrix -> IMatrix -> IO SX
sx_indexed__2 x = casadi__SX__indexed__2 (castSX x)


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


-- classy wrapper
sx_indexed__3 :: SXClass a => a -> IMatrix -> Slice -> IO SX
sx_indexed__3 x = casadi__SX__indexed__3 (castSX x)


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


-- classy wrapper
sx_indexed__4 :: SXClass a => a -> Slice -> IMatrix -> IO SX
sx_indexed__4 x = casadi__SX__indexed__4 (castSX x)


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


-- classy wrapper
sx_indexed__5 :: SXClass a => a -> Slice -> Slice -> IO SX
sx_indexed__5 x = casadi__SX__indexed__5 (castSX x)


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


-- classy wrapper
sx_indexed_assignment__0 :: SXClass a => a -> Slice -> SX -> IO ()
sx_indexed_assignment__0 x = casadi__SX__indexed_assignment__0 (castSX x)


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


-- classy wrapper
sx_indexed_assignment__1 :: SXClass a => a -> Sparsity -> SX -> IO ()
sx_indexed_assignment__1 x = casadi__SX__indexed_assignment__1 (castSX x)


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


-- classy wrapper
sx_indexed_assignment__2 :: SXClass a => a -> IMatrix -> IMatrix -> SX -> IO ()
sx_indexed_assignment__2 x = casadi__SX__indexed_assignment__2 (castSX x)


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


-- classy wrapper
sx_indexed_assignment__3 :: SXClass a => a -> IMatrix -> Slice -> SX -> IO ()
sx_indexed_assignment__3 x = casadi__SX__indexed_assignment__3 (castSX x)


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


-- classy wrapper
sx_indexed_assignment__4 :: SXClass a => a -> Slice -> IMatrix -> SX -> IO ()
sx_indexed_assignment__4 x = casadi__SX__indexed_assignment__4 (castSX x)


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


-- classy wrapper
sx_indexed_assignment__5 :: SXClass a => a -> Slice -> Slice -> SX -> IO ()
sx_indexed_assignment__5 x = casadi__SX__indexed_assignment__5 (castSX x)


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


-- classy wrapper
sx_indexed_one_based__0 :: SXClass a => a -> Int -> IO SX
sx_indexed_one_based__0 x = casadi__SX__indexed_one_based__0 (castSX x)


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


-- classy wrapper
sx_indexed_one_based__1 :: SXClass a => a -> Int -> Int -> IO SX
sx_indexed_one_based__1 x = casadi__SX__indexed_one_based__1 (castSX x)


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


-- classy wrapper
sx_indexed_one_based__2 :: SXClass a => a -> IMatrix -> IO SX
sx_indexed_one_based__2 x = casadi__SX__indexed_one_based__2 (castSX x)


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


-- classy wrapper
sx_indexed_one_based_assignment__0 :: SXClass a => a -> Int -> SXElement -> IO ()
sx_indexed_one_based_assignment__0 x = casadi__SX__indexed_one_based_assignment__0 (castSX x)


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


-- classy wrapper
sx_indexed_one_based_assignment__1 :: SXClass a => a -> Int -> Int -> SXElement -> IO ()
sx_indexed_one_based_assignment__1 x = casadi__SX__indexed_one_based_assignment__1 (castSX x)


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


-- classy wrapper
sx_indexed_one_based_assignment__2 :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_indexed_one_based_assignment__2 x = casadi__SX__indexed_one_based_assignment__2 (castSX x)


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


-- classy wrapper
sx_indexed_zero_based__0 :: SXClass a => a -> Int -> IO SX
sx_indexed_zero_based__0 x = casadi__SX__indexed_zero_based__0 (castSX x)


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


-- classy wrapper
sx_indexed_zero_based__1 :: SXClass a => a -> Int -> Int -> IO SX
sx_indexed_zero_based__1 x = casadi__SX__indexed_zero_based__1 (castSX x)


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


-- classy wrapper
sx_indexed_zero_based__2 :: SXClass a => a -> IMatrix -> IO SX
sx_indexed_zero_based__2 x = casadi__SX__indexed_zero_based__2 (castSX x)


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


-- classy wrapper
sx_indexed_zero_based_assignment__0 :: SXClass a => a -> Int -> SXElement -> IO ()
sx_indexed_zero_based_assignment__0 x = casadi__SX__indexed_zero_based_assignment__0 (castSX x)


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


-- classy wrapper
sx_indexed_zero_based_assignment__1 :: SXClass a => a -> Int -> Int -> SXElement -> IO ()
sx_indexed_zero_based_assignment__1 x = casadi__SX__indexed_zero_based_assignment__1 (castSX x)


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


-- classy wrapper
sx_indexed_zero_based_assignment__2 :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_indexed_zero_based_assignment__2 x = casadi__SX__indexed_zero_based_assignment__2 (castSX x)


-- direct wrapper
foreign import ccall unsafe "casadi__SX__inf__0" c_casadi__SX__inf__0
  :: Ptr (Ptr StdString) -> IO (Ptr SX')
casadi__SX__inf__0
  :: IO SX
casadi__SX__inf__0  =

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


-- classy wrapper
sx_inf__0 :: IO SX
sx_inf__0 = casadi__SX__inf__0


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


-- classy wrapper
sx_inf__1 :: Int -> IO SX
sx_inf__1 = casadi__SX__inf__1


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


-- classy wrapper
sx_inf__2 :: Int -> Int -> IO SX
sx_inf__2 = casadi__SX__inf__2


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


-- classy wrapper
sx_inf__3 :: Sparsity -> IO SX
sx_inf__3 = casadi__SX__inf__3


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


-- classy wrapper
sx_isConstant :: SXClass a => a -> IO Bool
sx_isConstant x = casadi__SX__isConstant (castSX x)


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


-- classy wrapper
sx_isDense :: SXClass a => a -> IO Bool
sx_isDense x = casadi__SX__isDense (castSX x)


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


-- classy wrapper
sx_isEmpty__0 :: SXClass a => a -> IO Bool
sx_isEmpty__0 x = casadi__SX__isEmpty__0 (castSX x)


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


-- classy wrapper
sx_isEmpty__1 :: SXClass a => a -> Bool -> IO Bool
sx_isEmpty__1 x = casadi__SX__isEmpty__1 (castSX x)


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


-- classy wrapper
sx_isEqual :: SXClass a => a -> SX -> IO Bool
sx_isEqual x = casadi__SX__isEqual (castSX x)


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


-- classy wrapper
sx_isIdentity :: SXClass a => a -> IO Bool
sx_isIdentity x = casadi__SX__isIdentity (castSX x)


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


-- classy wrapper
sx_isInteger :: SXClass a => a -> IO Bool
sx_isInteger x = casadi__SX__isInteger (castSX x)


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


-- classy wrapper
sx_isMinusOne :: SXClass a => a -> IO Bool
sx_isMinusOne x = casadi__SX__isMinusOne (castSX x)


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


-- classy wrapper
sx_isOne :: SXClass a => a -> IO Bool
sx_isOne x = casadi__SX__isOne (castSX x)


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


-- classy wrapper
sx_isRegular :: SXClass a => a -> IO Bool
sx_isRegular x = casadi__SX__isRegular (castSX x)


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


-- classy wrapper
sx_isScalar__0 :: SXClass a => a -> IO Bool
sx_isScalar__0 x = casadi__SX__isScalar__0 (castSX x)


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


-- classy wrapper
sx_isScalar__1 :: SXClass a => a -> Bool -> IO Bool
sx_isScalar__1 x = casadi__SX__isScalar__1 (castSX x)


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


-- classy wrapper
sx_isSmooth :: SXClass a => a -> IO Bool
sx_isSmooth x = casadi__SX__isSmooth (castSX x)


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


-- classy wrapper
sx_isSquare :: SXClass a => a -> IO Bool
sx_isSquare x = casadi__SX__isSquare (castSX x)


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


-- classy wrapper
sx_isSymbolic :: SXClass a => a -> IO Bool
sx_isSymbolic x = casadi__SX__isSymbolic (castSX x)


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


-- classy wrapper
sx_isSymbolicSparse :: SXClass a => a -> IO Bool
sx_isSymbolicSparse x = casadi__SX__isSymbolicSparse (castSX x)


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


-- classy wrapper
sx_isTril :: SXClass a => a -> IO Bool
sx_isTril x = casadi__SX__isTril (castSX x)


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


-- classy wrapper
sx_isTriu :: SXClass a => a -> IO Bool
sx_isTriu x = casadi__SX__isTriu (castSX x)


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


-- classy wrapper
sx_isVector :: SXClass a => a -> IO Bool
sx_isVector x = casadi__SX__isVector (castSX x)


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


-- classy wrapper
sx_isZero :: SXClass a => a -> IO Bool
sx_isZero x = casadi__SX__isZero (castSX x)


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


-- classy wrapper
sx_log :: SXClass a => a -> IO SX
sx_log x = casadi__SX__log (castSX x)


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


-- classy wrapper
sx_log10 :: SXClass a => a -> IO SX
sx_log10 x = casadi__SX__log10 (castSX x)


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


-- classy wrapper
sx_logic_and :: SXClass a => a -> SX -> IO SX
sx_logic_and x = casadi__SX__logic_and (castSX x)


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


-- classy wrapper
sx_logic_not :: SXClass a => a -> IO SX
sx_logic_not x = casadi__SX__logic_not (castSX x)


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


-- classy wrapper
sx_logic_or :: SXClass a => a -> SX -> IO SX
sx_logic_or x = casadi__SX__logic_or (castSX x)


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


-- classy wrapper
sx_matrix_matrix :: Int -> SX -> SX -> IO SX
sx_matrix_matrix = casadi__SX__matrix_matrix


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


-- classy wrapper
sx_matrix_scalar :: Int -> SX -> SX -> IO SX
sx_matrix_scalar = casadi__SX__matrix_scalar


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


-- classy wrapper
sx_mul__0 :: SXClass a => a -> SX -> IO SX
sx_mul__0 x = casadi__SX__mul__0 (castSX x)


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


-- classy wrapper
sx_mul__1 :: SXClass a => a -> SX -> Sparsity -> IO SX
sx_mul__1 x = casadi__SX__mul__1 (castSX x)


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


-- classy wrapper
sx_mul_full__0 :: SXClass a => a -> SX -> IO SX
sx_mul_full__0 x = casadi__SX__mul_full__0 (castSX x)


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


-- classy wrapper
sx_mul_full__1 :: SXClass a => a -> SX -> Sparsity -> IO SX
sx_mul_full__1 x = casadi__SX__mul_full__1 (castSX x)


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


-- classy wrapper
sx_mul_no_alloc_nn__0 :: SX -> Vector SXElement -> Vector SXElement -> IO ()
sx_mul_no_alloc_nn__0 = casadi__SX__mul_no_alloc_nn__0


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


-- classy wrapper
sx_mul_no_alloc_nn__1 :: SX -> SX -> SX -> Vector SXElement -> IO ()
sx_mul_no_alloc_nn__1 = casadi__SX__mul_no_alloc_nn__1


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


-- classy wrapper
sx_mul_no_alloc_nn__2 :: SX -> SX -> SX -> IO ()
sx_mul_no_alloc_nn__2 = casadi__SX__mul_no_alloc_nn__2


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


-- classy wrapper
sx_mul_no_alloc_nt :: SX -> SX -> SX -> IO ()
sx_mul_no_alloc_nt = casadi__SX__mul_no_alloc_nt


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


-- classy wrapper
sx_mul_no_alloc_tn__0 :: SX -> Vector SXElement -> Vector SXElement -> IO ()
sx_mul_no_alloc_tn__0 = casadi__SX__mul_no_alloc_tn__0


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


-- classy wrapper
sx_mul_no_alloc_tn__1 :: SX -> SX -> SX -> IO ()
sx_mul_no_alloc_tn__1 = casadi__SX__mul_no_alloc_tn__1


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


-- classy wrapper
sx_mul_smart :: SXClass a => a -> SX -> Sparsity -> IO SX
sx_mul_smart x = casadi__SX__mul_smart (castSX x)


-- direct wrapper
foreign import ccall unsafe "casadi__SX__nan__0" c_casadi__SX__nan__0
  :: Ptr (Ptr StdString) -> IO (Ptr SX')
casadi__SX__nan__0
  :: IO SX
casadi__SX__nan__0  =

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


-- classy wrapper
sx_nan__0 :: IO SX
sx_nan__0 = casadi__SX__nan__0


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


-- classy wrapper
sx_nan__1 :: Int -> IO SX
sx_nan__1 = casadi__SX__nan__1


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


-- classy wrapper
sx_nan__2 :: Int -> Int -> IO SX
sx_nan__2 = casadi__SX__nan__2


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


-- classy wrapper
sx_nan__3 :: Sparsity -> IO SX
sx_nan__3 = casadi__SX__nan__3


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


-- classy wrapper
sx_numel :: SXClass a => a -> IO Int
sx_numel x = casadi__SX__numel (castSX x)


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


-- classy wrapper
sx_nz_indexed :: SXClass a => a -> Slice -> IO SX
sx_nz_indexed x = casadi__SX__nz_indexed (castSX x)


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


-- classy wrapper
sx_nz_indexed_assignment :: SXClass a => a -> Slice -> SX -> IO ()
sx_nz_indexed_assignment x = casadi__SX__nz_indexed_assignment (castSX x)


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


-- classy wrapper
sx_nz_indexed_one_based__0 :: SXClass a => a -> IMatrix -> IO SX
sx_nz_indexed_one_based__0 x = casadi__SX__nz_indexed_one_based__0 (castSX x)


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


-- classy wrapper
sx_nz_indexed_one_based__1 :: SXClass a => a -> Int -> IO SX
sx_nz_indexed_one_based__1 x = casadi__SX__nz_indexed_one_based__1 (castSX x)


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


-- classy wrapper
sx_nz_indexed_one_based_assignment__0 :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_nz_indexed_one_based_assignment__0 x = casadi__SX__nz_indexed_one_based_assignment__0 (castSX x)


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


-- classy wrapper
sx_nz_indexed_one_based_assignment__1 :: SXClass a => a -> Int -> SXElement -> IO ()
sx_nz_indexed_one_based_assignment__1 x = casadi__SX__nz_indexed_one_based_assignment__1 (castSX x)


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


-- classy wrapper
sx_nz_indexed_zero_based__0 :: SXClass a => a -> IMatrix -> IO SX
sx_nz_indexed_zero_based__0 x = casadi__SX__nz_indexed_zero_based__0 (castSX x)


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


-- classy wrapper
sx_nz_indexed_zero_based__1 :: SXClass a => a -> Int -> IO SX
sx_nz_indexed_zero_based__1 x = casadi__SX__nz_indexed_zero_based__1 (castSX x)


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


-- classy wrapper
sx_nz_indexed_zero_based_assignment__0 :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_nz_indexed_zero_based_assignment__0 x = casadi__SX__nz_indexed_zero_based_assignment__0 (castSX x)


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


-- classy wrapper
sx_nz_indexed_zero_based_assignment__1 :: SXClass a => a -> Int -> SXElement -> IO ()
sx_nz_indexed_zero_based_assignment__1 x = casadi__SX__nz_indexed_zero_based_assignment__1 (castSX x)


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


-- classy wrapper
sx_ones__0 :: Sparsity -> IO SX
sx_ones__0 = casadi__SX__ones__0


-- direct wrapper
foreign import ccall unsafe "casadi__SX__ones__1" c_casadi__SX__ones__1
  :: Ptr (Ptr StdString) -> IO (Ptr SX')
casadi__SX__ones__1
  :: IO SX
casadi__SX__ones__1  =

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


-- classy wrapper
sx_ones__1 :: IO SX
sx_ones__1 = casadi__SX__ones__1


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


-- classy wrapper
sx_ones__2 :: Int -> IO SX
sx_ones__2 = casadi__SX__ones__2


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


-- classy wrapper
sx_ones__3 :: Int -> Int -> IO SX
sx_ones__3 = casadi__SX__ones__3


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


-- classy wrapper
sx_printDense :: SXClass a => a -> IO ()
sx_printDense x = casadi__SX__printDense (castSX x)


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


-- classy wrapper
sx_printScalar :: SXClass a => a -> IO ()
sx_printScalar x = casadi__SX__printScalar (castSX x)


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


-- classy wrapper
sx_printSparse :: SXClass a => a -> IO ()
sx_printSparse x = casadi__SX__printSparse (castSX x)


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


-- classy wrapper
sx_printVector :: SXClass a => a -> IO ()
sx_printVector x = casadi__SX__printVector (castSX x)


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


-- classy wrapper
sx_printme :: SXClass a => a -> SX -> IO SX
sx_printme x = casadi__SX__printme (castSX x)


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


-- classy wrapper
sx_quad_form :: Vector SXElement -> SX -> IO SXElement
sx_quad_form = casadi__SX__quad_form


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


-- classy wrapper
sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
sx_remove x = casadi__SX__remove (castSX x)


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


-- classy wrapper
sx_repmat__0 :: SX -> Int -> IO SX
sx_repmat__0 = casadi__SX__repmat__0


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


-- classy wrapper
sx_repmat__1 :: SX -> Int -> Int -> IO SX
sx_repmat__1 = casadi__SX__repmat__1


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


-- classy wrapper
sx_repmat__2 :: SX -> Sparsity -> IO SX
sx_repmat__2 = casadi__SX__repmat__2


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


-- classy wrapper
sx_repmat__3 :: SXElement -> Sparsity -> IO SX
sx_repmat__3 = casadi__SX__repmat__3


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


-- classy wrapper
sx_reserve__0 :: SXClass a => a -> Int -> Int -> IO ()
sx_reserve__0 x = casadi__SX__reserve__0 (castSX x)


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


-- classy wrapper
sx_reserve__1 :: SXClass a => a -> Int -> IO ()
sx_reserve__1 x = casadi__SX__reserve__1 (castSX x)


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


-- classy wrapper
sx_resize :: SXClass a => a -> Int -> Int -> IO ()
sx_resize x = casadi__SX__resize (castSX x)


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


-- classy wrapper
sx_row__0 :: SXClass a => a -> Int -> IO Int
sx_row__0 x = casadi__SX__row__0 (castSX x)


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


-- classy wrapper
sx_row__1 :: SXClass a => a -> IO (Vector Int)
sx_row__1 x = casadi__SX__row__1 (castSX x)


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


-- classy wrapper
sx_sanityCheck__0 :: SXClass a => a -> IO ()
sx_sanityCheck__0 x = casadi__SX__sanityCheck__0 (castSX x)


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


-- classy wrapper
sx_sanityCheck__1 :: SXClass a => a -> Bool -> IO ()
sx_sanityCheck__1 x = casadi__SX__sanityCheck__1 (castSX x)


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


-- classy wrapper
sx_scalar_matrix :: Int -> SX -> SX -> IO SX
sx_scalar_matrix = casadi__SX__scalar_matrix


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


-- classy wrapper
sx_set__0 :: SXClass a => a -> SX -> IO ()
sx_set__0 x = casadi__SX__set__0 (castSX x)


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


-- classy wrapper
sx_set__1 :: SXClass a => a -> SX -> SparsityType -> IO ()
sx_set__1 x = casadi__SX__set__1 (castSX x)


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


-- classy wrapper
sx_set__2 :: SXClass a => a -> Vector SXElement -> IO ()
sx_set__2 x = casadi__SX__set__2 (castSX x)


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


-- classy wrapper
sx_set__3 :: SXClass a => a -> Vector SXElement -> SparsityType -> IO ()
sx_set__3 x = casadi__SX__set__3 (castSX x)


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


-- classy wrapper
sx_set__4 :: SXClass a => a -> SXElement -> IO ()
sx_set__4 x = casadi__SX__set__4 (castSX x)


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


-- classy wrapper
sx_set__5 :: SXClass a => a -> SXElement -> SparsityType -> IO ()
sx_set__5 x = casadi__SX__set__5 (castSX x)


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


-- classy wrapper
sx_setAll :: SXClass a => a -> SXElement -> IO ()
sx_setAll x = casadi__SX__setAll (castSX x)


-- direct wrapper
foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__0" c_casadi__SX__setEqualityCheckingDepth__0
  :: Ptr (Ptr StdString) -> IO ()
casadi__SX__setEqualityCheckingDepth__0
  :: IO ()
casadi__SX__setEqualityCheckingDepth__0  =

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


-- classy wrapper
sx_setEqualityCheckingDepth__0 :: IO ()
sx_setEqualityCheckingDepth__0 = casadi__SX__setEqualityCheckingDepth__0


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


-- classy wrapper
sx_setEqualityCheckingDepth__1 :: Int -> IO ()
sx_setEqualityCheckingDepth__1 = casadi__SX__setEqualityCheckingDepth__1


-- direct wrapper
foreign import ccall unsafe "casadi__SX__setMaxNumCallsInPrint__0" c_casadi__SX__setMaxNumCallsInPrint__0
  :: Ptr (Ptr StdString) -> IO ()
casadi__SX__setMaxNumCallsInPrint__0
  :: IO ()
casadi__SX__setMaxNumCallsInPrint__0  =

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


-- classy wrapper
sx_setMaxNumCallsInPrint__0 :: IO ()
sx_setMaxNumCallsInPrint__0 = casadi__SX__setMaxNumCallsInPrint__0


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


-- classy wrapper
sx_setMaxNumCallsInPrint__1 :: Int -> IO ()
sx_setMaxNumCallsInPrint__1 = casadi__SX__setMaxNumCallsInPrint__1


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


-- classy wrapper
sx_setNZ__0 :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_setNZ__0 x = casadi__SX__setNZ__0 (castSX x)


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


-- classy wrapper
sx_setNZ__1 :: SXClass a => a -> Slice -> SX -> IO ()
sx_setNZ__1 x = casadi__SX__setNZ__1 (castSX x)


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


-- classy wrapper
sx_setNZ__2 :: SXClass a => a -> Vector Int -> SX -> IO ()
sx_setNZ__2 x = casadi__SX__setNZ__2 (castSX x)


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


-- classy wrapper
sx_setNZ__3 :: SXClass a => a -> Int -> SX -> IO ()
sx_setNZ__3 x = casadi__SX__setNZ__3 (castSX x)


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


-- classy wrapper
sx_setPrecision :: Int -> IO ()
sx_setPrecision = casadi__SX__setPrecision


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


-- classy wrapper
sx_setScientific :: Bool -> IO ()
sx_setScientific = casadi__SX__setScientific


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


-- classy wrapper
sx_setSparse__0 :: SXClass a => a -> Sparsity -> IO SX
sx_setSparse__0 x = casadi__SX__setSparse__0 (castSX x)


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


-- classy wrapper
sx_setSparse__1 :: SXClass a => a -> Sparsity -> Bool -> IO SX
sx_setSparse__1 x = casadi__SX__setSparse__1 (castSX x)


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


-- classy wrapper
sx_setSub__0 :: SXClass a => a -> SX -> Sparsity -> Int -> IO ()
sx_setSub__0 x = casadi__SX__setSub__0 (castSX x)


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


-- classy wrapper
sx_setSub__1 :: SXClass a => a -> SX -> Int -> Slice -> IO ()
sx_setSub__1 x = casadi__SX__setSub__1 (castSX x)


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


-- classy wrapper
sx_setSub__2 :: SXClass a => a -> SX -> Slice -> Int -> IO ()
sx_setSub__2 x = casadi__SX__setSub__2 (castSX x)


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


-- classy wrapper
sx_setSub__3 :: SXClass a => a -> SX -> IMatrix -> IMatrix -> IO ()
sx_setSub__3 x = casadi__SX__setSub__3 (castSX x)


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


-- classy wrapper
sx_setSub__4 :: SXClass a => a -> SX -> Slice -> IMatrix -> IO ()
sx_setSub__4 x = casadi__SX__setSub__4 (castSX x)


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


-- classy wrapper
sx_setSub__5 :: SXClass a => a -> SX -> IMatrix -> Slice -> IO ()
sx_setSub__5 x = casadi__SX__setSub__5 (castSX x)


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


-- classy wrapper
sx_setSub__6 :: SXClass a => a -> SX -> Int -> IMatrix -> IO ()
sx_setSub__6 x = casadi__SX__setSub__6 (castSX x)


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


-- classy wrapper
sx_setSub__7 :: SXClass a => a -> SX -> Vector Int -> IMatrix -> IO ()
sx_setSub__7 x = casadi__SX__setSub__7 (castSX x)


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


-- classy wrapper
sx_setSub__8 :: SXClass a => a -> SX -> IMatrix -> Int -> IO ()
sx_setSub__8 x = casadi__SX__setSub__8 (castSX x)


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


-- classy wrapper
sx_setSub__9 :: SXClass a => a -> SX -> IMatrix -> Vector Int -> IO ()
sx_setSub__9 x = casadi__SX__setSub__9 (castSX x)


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


-- classy wrapper
sx_setSub__10 :: SXClass a => a -> SX -> Slice -> Slice -> IO ()
sx_setSub__10 x = casadi__SX__setSub__10 (castSX x)


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


-- classy wrapper
sx_setSub__11 :: SXClass a => a -> SX -> Vector Int -> Slice -> IO ()
sx_setSub__11 x = casadi__SX__setSub__11 (castSX x)


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


-- classy wrapper
sx_setSub__12 :: SXClass a => a -> SX -> Slice -> Vector Int -> IO ()
sx_setSub__12 x = casadi__SX__setSub__12 (castSX x)


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


-- classy wrapper
sx_setSub__13 :: SXClass a => a -> SX -> Vector Int -> Vector Int -> IO ()
sx_setSub__13 x = casadi__SX__setSub__13 (castSX x)


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


-- classy wrapper
sx_setSub__14 :: SXClass a => a -> SX -> Int -> Vector Int -> IO ()
sx_setSub__14 x = casadi__SX__setSub__14 (castSX x)


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


-- classy wrapper
sx_setSub__15 :: SXClass a => a -> SX -> Vector Int -> Int -> IO ()
sx_setSub__15 x = casadi__SX__setSub__15 (castSX x)


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


-- classy wrapper
sx_setSub__16 :: SXClass a => a -> SX -> Int -> Int -> IO ()
sx_setSub__16 x = casadi__SX__setSub__16 (castSX x)


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


-- classy wrapper
sx_setWidth :: Int -> IO ()
sx_setWidth = casadi__SX__setWidth


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


-- classy wrapper
sx_setZero :: SXClass a => a -> IO ()
sx_setZero x = casadi__SX__setZero (castSX x)


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


-- classy wrapper
sx_sign :: SXClass a => a -> IO SX
sx_sign x = casadi__SX__sign (castSX x)


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


-- classy wrapper
sx_sin :: SXClass a => a -> IO SX
sx_sin x = casadi__SX__sin (castSX x)


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


-- classy wrapper
sx_sinh :: SXClass a => a -> IO SX
sx_sinh x = casadi__SX__sinh (castSX x)


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


-- classy wrapper
sx_size__0 :: SXClass a => a -> SparsityType -> IO Int
sx_size__0 x = casadi__SX__size__0 (castSX x)


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


-- classy wrapper
sx_size__1 :: SXClass a => a -> IO Int
sx_size__1 x = casadi__SX__size__1 (castSX x)


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


-- classy wrapper
sx_size1 :: SXClass a => a -> IO Int
sx_size1 x = casadi__SX__size1 (castSX x)


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


-- classy wrapper
sx_size2 :: SXClass a => a -> IO Int
sx_size2 x = casadi__SX__size2 (castSX x)


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


-- classy wrapper
sx_sizeD :: SXClass a => a -> IO Int
sx_sizeD x = casadi__SX__sizeD (castSX x)


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


-- classy wrapper
sx_sizeL :: SXClass a => a -> IO Int
sx_sizeL x = casadi__SX__sizeL (castSX x)


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


-- classy wrapper
sx_sizeU :: SXClass a => a -> IO Int
sx_sizeU x = casadi__SX__sizeU (castSX x)


-- direct wrapper
foreign import ccall unsafe "casadi__SX__sparse__0" c_casadi__SX__sparse__0
  :: Ptr (Ptr StdString) -> IO (Ptr SX')
casadi__SX__sparse__0
  :: IO SX
casadi__SX__sparse__0  =

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


-- classy wrapper
sx_sparse__0 :: IO SX
sx_sparse__0 = casadi__SX__sparse__0


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


-- classy wrapper
sx_sparse__1 :: Int -> IO SX
sx_sparse__1 = casadi__SX__sparse__1


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


-- classy wrapper
sx_sparse__2 :: Int -> Int -> IO SX
sx_sparse__2 = casadi__SX__sparse__2


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


-- classy wrapper
sx_sparsify__0 :: SXClass a => a -> IO ()
sx_sparsify__0 x = casadi__SX__sparsify__0 (castSX x)


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


-- classy wrapper
sx_sparsify__1 :: SXClass a => a -> Double -> IO ()
sx_sparsify__1 x = casadi__SX__sparsify__1 (castSX x)


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


-- classy wrapper
sx_sparsity__0 :: SXClass a => a -> IO Sparsity
sx_sparsity__0 x = casadi__SX__sparsity__0 (castSX x)


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


-- classy wrapper
sx_sparsity__1 :: SXClass a => a -> IO Sparsity
sx_sparsity__1 x = casadi__SX__sparsity__1 (castSX x)


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


-- classy wrapper
sx_sparsityRef__0 :: SXClass a => a -> IO Sparsity
sx_sparsityRef__0 x = casadi__SX__sparsityRef__0 (castSX x)


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


-- classy wrapper
sx_sparsityRef__1 :: SXClass a => a -> IO Sparsity
sx_sparsityRef__1 x = casadi__SX__sparsityRef__1 (castSX x)


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


-- classy wrapper
sx_sqrt :: SXClass a => a -> IO SX
sx_sqrt x = casadi__SX__sqrt (castSX x)


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


-- classy wrapper
sx_sub__0 :: SXClass a => a -> Sparsity -> IO SX
sx_sub__0 x = casadi__SX__sub__0 (castSX x)


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


-- classy wrapper
sx_sub__1 :: SXClass a => a -> Sparsity -> Int -> IO SX
sx_sub__1 x = casadi__SX__sub__1 (castSX x)


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


-- classy wrapper
sx_sub__2 :: SXClass a => a -> IMatrix -> IMatrix -> IO SX
sx_sub__2 x = casadi__SX__sub__2 (castSX x)


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


-- classy wrapper
sx_sub__3 :: SXClass a => a -> Slice -> IMatrix -> IO SX
sx_sub__3 x = casadi__SX__sub__3 (castSX x)


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


-- classy wrapper
sx_sub__4 :: SXClass a => a -> IMatrix -> Slice -> IO SX
sx_sub__4 x = casadi__SX__sub__4 (castSX x)


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


-- classy wrapper
sx_sub__5 :: SXClass a => a -> Int -> IMatrix -> IO SX
sx_sub__5 x = casadi__SX__sub__5 (castSX x)


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


-- classy wrapper
sx_sub__6 :: SXClass a => a -> Vector Int -> IMatrix -> IO SX
sx_sub__6 x = casadi__SX__sub__6 (castSX x)


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


-- classy wrapper
sx_sub__7 :: SXClass a => a -> IMatrix -> Int -> IO SX
sx_sub__7 x = casadi__SX__sub__7 (castSX x)


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


-- classy wrapper
sx_sub__8 :: SXClass a => a -> IMatrix -> Vector Int -> IO SX
sx_sub__8 x = casadi__SX__sub__8 (castSX x)


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


-- classy wrapper
sx_sub__9 :: SXClass a => a -> Int -> Slice -> IO SX
sx_sub__9 x = casadi__SX__sub__9 (castSX x)


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


-- classy wrapper
sx_sub__10 :: SXClass a => a -> Slice -> Int -> IO SX
sx_sub__10 x = casadi__SX__sub__10 (castSX x)


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


-- classy wrapper
sx_sub__11 :: SXClass a => a -> Slice -> Slice -> IO SX
sx_sub__11 x = casadi__SX__sub__11 (castSX x)


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


-- classy wrapper
sx_sub__12 :: SXClass a => a -> Vector Int -> Slice -> IO SX
sx_sub__12 x = casadi__SX__sub__12 (castSX x)


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


-- classy wrapper
sx_sub__13 :: SXClass a => a -> Slice -> Vector Int -> IO SX
sx_sub__13 x = casadi__SX__sub__13 (castSX x)


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


-- classy wrapper
sx_sub__14 :: SXClass a => a -> Vector Int -> Vector Int -> IO SX
sx_sub__14 x = casadi__SX__sub__14 (castSX x)


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


-- classy wrapper
sx_sub__15 :: SXClass a => a -> Int -> Vector Int -> IO SX
sx_sub__15 x = casadi__SX__sub__15 (castSX x)


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


-- classy wrapper
sx_sub__16 :: SXClass a => a -> Vector Int -> Int -> IO SX
sx_sub__16 x = casadi__SX__sub__16 (castSX x)


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


-- classy wrapper
sx_sub__17 :: SXClass a => a -> Int -> Int -> IO SX
sx_sub__17 x = casadi__SX__sub__17 (castSX x)


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


-- classy wrapper
sx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX))
sx_sym__0 = casadi__SX__sym__0


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


-- classy wrapper
sx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX))
sx_sym__1 = casadi__SX__sym__1


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


-- classy wrapper
sx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector SX)
sx_sym__2 = casadi__SX__sym__2


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


-- classy wrapper
sx_sym__3 :: String -> Sparsity -> Int -> IO (Vector SX)
sx_sym__3 = casadi__SX__sym__3


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


-- classy wrapper
sx_sym__4 :: String -> Sparsity -> IO SX
sx_sym__4 = casadi__SX__sym__4


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


-- classy wrapper
sx_sym__5 :: String -> IO SX
sx_sym__5 = casadi__SX__sym__5


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


-- classy wrapper
sx_sym__6 :: String -> Int -> IO SX
sx_sym__6 = casadi__SX__sym__6


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


-- classy wrapper
sx_sym__7 :: String -> Int -> Int -> IO SX
sx_sym__7 = casadi__SX__sym__7


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


-- classy wrapper
sx_tan :: SXClass a => a -> IO SX
sx_tan x = casadi__SX__tan (castSX x)


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


-- classy wrapper
sx_tanh :: SXClass a => a -> IO SX
sx_tanh x = casadi__SX__tanh (castSX x)


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


-- classy wrapper
sx_toScalar :: SXClass a => a -> IO SXElement
sx_toScalar x = casadi__SX__toScalar (castSX x)


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


-- classy wrapper
sx_trans :: SXClass a => a -> IO SX
sx_trans x = casadi__SX__trans (castSX x)


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


-- classy wrapper
sx_triplet__0 :: Vector Int -> Vector Int -> Vector SXElement -> Int -> Int -> IO SX
sx_triplet__0 = casadi__SX__triplet__0


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


-- classy wrapper
sx_triplet__1 :: Vector Int -> Vector Int -> Vector SXElement -> IO SX
sx_triplet__1 = casadi__SX__triplet__1


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


-- classy wrapper
sx_unary :: Int -> SX -> IO SX
sx_unary = casadi__SX__unary


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


-- classy wrapper
sx_zeros__0 :: Sparsity -> IO SX
sx_zeros__0 = casadi__SX__zeros__0


-- direct wrapper
foreign import ccall unsafe "casadi__SX__zeros__1" c_casadi__SX__zeros__1
  :: Ptr (Ptr StdString) -> IO (Ptr SX')
casadi__SX__zeros__1
  :: IO SX
casadi__SX__zeros__1  =

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


-- classy wrapper
sx_zeros__1 :: IO SX
sx_zeros__1 = casadi__SX__zeros__1


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


-- classy wrapper
sx_zeros__2 :: Int -> IO SX
sx_zeros__2 = casadi__SX__zeros__2


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


-- classy wrapper
sx_zeros__3 :: Int -> Int -> IO SX
sx_zeros__3 = casadi__SX__zeros__3