casadi-bindings-core-1.9.0.4: Casadi/Core/Tools.hs

{-# OPTIONS_GHC -Wall #-}

module Casadi.Core.Tools
       (
         addMultiple__0,
         addMultiple__1,
         addMultiple__2,
         addMultiple__3,
         addMultiple__4,
         addMultiple__5,
         adj__0,
         adj__1,
         adj__2,
         blkdiag__0,
         blkdiag__1,
         blkdiag__2,
         blkdiag__3,
         blkdiag__4,
         blockcat__0,
         blockcat__1,
         blockcat__2,
         blockcat__3,
         blocksplit__0,
         blocksplit__1,
         blocksplit__10,
         blocksplit__11,
         blocksplit__12,
         blocksplit__13,
         blocksplit__14,
         blocksplit__15,
         blocksplit__2,
         blocksplit__3,
         blocksplit__4,
         blocksplit__5,
         blocksplit__6,
         blocksplit__7,
         blocksplit__8,
         blocksplit__9,
         cofactor__0,
         cofactor__1,
         cofactor__2,
         collocationPoints__0,
         collocationPoints__1,
         complement,
         compress__0,
         compress__1,
         controldaeIn__0,
         controldaeIn__1,
         controldaeIn__10,
         controldaeIn__11,
         controldaeIn__12,
         controldaeIn__13,
         controldaeIn__14,
         controldaeIn__15,
         controldaeIn__16,
         controldaeIn__17,
         controldaeIn__18,
         controldaeIn__19,
         controldaeIn__2,
         controldaeIn__20,
         controldaeIn__21,
         controldaeIn__22,
         controldaeIn__23,
         controldaeIn__24,
         controldaeIn__25,
         controldaeIn__26,
         controldaeIn__27,
         controldaeIn__28,
         controldaeIn__29,
         controldaeIn__3,
         controldaeIn__4,
         controldaeIn__5,
         controldaeIn__6,
         controldaeIn__7,
         controldaeIn__8,
         controldaeIn__9,
         controlsimulatorIn__0,
         controlsimulatorIn__1,
         controlsimulatorIn__10,
         controlsimulatorIn__11,
         controlsimulatorIn__2,
         controlsimulatorIn__3,
         controlsimulatorIn__4,
         controlsimulatorIn__5,
         controlsimulatorIn__6,
         controlsimulatorIn__7,
         controlsimulatorIn__8,
         controlsimulatorIn__9,
         countNodes__0,
         countNodes__1,
         createParent__0,
         createParent__1,
         createParent__2,
         cross__0,
         cross__1,
         cross__2,
         cross__3,
         cross__4,
         cross__5,
         cross__6,
         cross__7,
         daeIn__0,
         daeIn__1,
         daeIn__10,
         daeIn__11,
         daeIn__12,
         daeIn__13,
         daeIn__14,
         daeIn__2,
         daeIn__3,
         daeIn__4,
         daeIn__5,
         daeIn__6,
         daeIn__7,
         daeIn__8,
         daeIn__9,
         daeOut__0,
         daeOut__1,
         daeOut__10,
         daeOut__11,
         daeOut__2,
         daeOut__3,
         daeOut__4,
         daeOut__5,
         daeOut__6,
         daeOut__7,
         daeOut__8,
         daeOut__9,
         dense__0,
         dense__1,
         dense__2,
         dense__3,
         dependsOn__0,
         dependsOn__1,
         det__0,
         det__1,
         det__2,
         det__3,
         diag__0,
         diag__1,
         diag__2,
         diag__3,
         dpleIn__0,
         dpleIn__1,
         dpleIn__2,
         dpleIn__3,
         dpleIn__4,
         dpleIn__5,
         dpleIn__6,
         dpleIn__7,
         dpleIn__8,
         dpleOut__0,
         dpleOut__1,
         dpleOut__2,
         dpleOut__3,
         dpleOut__4,
         dpleOut__5,
         eig_symbolic,
         evalf__0,
         evalf__1,
         expand,
         explicitRK__0,
         explicitRK__1,
         explicitRK__2,
         explicitRK__3,
         extractShared__0,
         extractShared__1,
         extractShared__2,
         extractShared__3,
         extractShared__4,
         extractShared__5,
         gauss_quadrature__0,
         gauss_quadrature__1,
         gauss_quadrature__2,
         getFree,
         getMinor__0,
         getMinor__1,
         getMinor__2,
         getOperatorRepresentation__0,
         getOperatorRepresentation__1,
         getSchemeEntryDoc,
         getSchemeEntryEnum,
         getSchemeEntryEnumName,
         getSchemeEntryName,
         getSchemeEntryNames,
         getSchemeName,
         getSchemeSize,
         getSymbols__0,
         getSymbols__1,
         getSymbols__2,
         gradFIn__0,
         gradFIn__1,
         gradFIn__2,
         gradFIn__3,
         gradFIn__4,
         gradFIn__5,
         gradFIn__6,
         gradFIn__7,
         gradFIn__8,
         gradFOut__0,
         gradFOut__1,
         gradFOut__10,
         gradFOut__11,
         gradFOut__2,
         gradFOut__3,
         gradFOut__4,
         gradFOut__5,
         gradFOut__6,
         gradFOut__7,
         gradFOut__8,
         gradFOut__9,
         gradient__0,
         gradient__1,
         graph_substitute__0,
         graph_substitute__1,
         heaviside,
         hessLagIn__0,
         hessLagIn__1,
         hessLagIn__10,
         hessLagIn__11,
         hessLagIn__12,
         hessLagIn__13,
         hessLagIn__14,
         hessLagIn__2,
         hessLagIn__3,
         hessLagIn__4,
         hessLagIn__5,
         hessLagIn__6,
         hessLagIn__7,
         hessLagIn__8,
         hessLagIn__9,
         hessLagOut__0,
         hessLagOut__1,
         hessLagOut__10,
         hessLagOut__11,
         hessLagOut__12,
         hessLagOut__13,
         hessLagOut__14,
         hessLagOut__15,
         hessLagOut__16,
         hessLagOut__17,
         hessLagOut__2,
         hessLagOut__3,
         hessLagOut__4,
         hessLagOut__5,
         hessLagOut__6,
         hessLagOut__7,
         hessLagOut__8,
         hessLagOut__9,
         hessian__0,
         hessian__1,
         hnlpIn__0,
         hnlpIn__1,
         hnlpIn__10,
         hnlpIn__11,
         hnlpIn__2,
         hnlpIn__3,
         hnlpIn__4,
         hnlpIn__5,
         hnlpIn__6,
         hnlpIn__7,
         hnlpIn__8,
         hnlpIn__9,
         horzcat__0,
         horzcat__1,
         horzcat__2,
         horzcat__3,
         horzcat__4,
         horzsplit__0,
         horzsplit__1,
         horzsplit__10,
         horzsplit__11,
         horzsplit__12,
         horzsplit__2,
         horzsplit__3,
         horzsplit__4,
         horzsplit__5,
         horzsplit__6,
         horzsplit__7,
         horzsplit__8,
         horzsplit__9,
         if_else__0,
         if_else__1,
         implicitRK,
         inner_prod__0,
         inner_prod__1,
         inner_prod__2,
         inner_prod__3,
         integratorIn__0,
         integratorIn__1,
         integratorIn__10,
         integratorIn__11,
         integratorIn__12,
         integratorIn__13,
         integratorIn__14,
         integratorIn__15,
         integratorIn__16,
         integratorIn__17,
         integratorIn__18,
         integratorIn__19,
         integratorIn__2,
         integratorIn__20,
         integratorIn__3,
         integratorIn__4,
         integratorIn__5,
         integratorIn__6,
         integratorIn__7,
         integratorIn__8,
         integratorIn__9,
         integratorOut__0,
         integratorOut__1,
         integratorOut__10,
         integratorOut__11,
         integratorOut__12,
         integratorOut__13,
         integratorOut__14,
         integratorOut__15,
         integratorOut__16,
         integratorOut__17,
         integratorOut__18,
         integratorOut__19,
         integratorOut__2,
         integratorOut__20,
         integratorOut__3,
         integratorOut__4,
         integratorOut__5,
         integratorOut__6,
         integratorOut__7,
         integratorOut__8,
         integratorOut__9,
         inv__0,
         inv__1,
         inv__2,
         inv__3,
         isDecreasing__0,
         isDecreasing__1,
         isEqual__0,
         isEqual__1,
         isEqual__2,
         isEqual__3,
         isIncreasing__0,
         isIncreasing__1,
         isMonotone__0,
         isMonotone__1,
         isNonDecreasing__0,
         isNonDecreasing__1,
         isNonIncreasing__0,
         isNonIncreasing__1,
         isRegular__0,
         isRegular__1,
         isStrictlyMonotone__0,
         isStrictlyMonotone__1,
         jacGIn__0,
         jacGIn__1,
         jacGIn__2,
         jacGIn__3,
         jacGIn__4,
         jacGIn__5,
         jacGIn__6,
         jacGIn__7,
         jacGIn__8,
         jacGOut__0,
         jacGOut__1,
         jacGOut__10,
         jacGOut__11,
         jacGOut__2,
         jacGOut__3,
         jacGOut__4,
         jacGOut__5,
         jacGOut__6,
         jacGOut__7,
         jacGOut__8,
         jacGOut__9,
         jacobianTimesVector__0,
         jacobianTimesVector__1,
         jacobian__0,
         jacobian__1,
         kron__0,
         kron__1,
         kron__2,
         kron__3,
         linsolIn__0,
         linsolIn__1,
         linsolIn__2,
         linsolIn__3,
         linsolIn__4,
         linsolIn__5,
         linsolIn__6,
         linsolIn__7,
         linsolIn__8,
         linsolOut__0,
         linsolOut__1,
         linsolOut__2,
         linsolOut__3,
         linsolOut__4,
         linsolOut__5,
         linspace__0,
         linspace__1,
         linspace__2,
         logic_and__0,
         logic_and__1,
         logic_and__2,
         logic_and__3,
         logic_and__4,
         logic_and__5,
         logic_and__6,
         logic_not__0,
         logic_not__1,
         logic_not__2,
         logic_not__3,
         logic_not__4,
         logic_not__5,
         logic_not__6,
         logic_or__0,
         logic_or__1,
         logic_or__2,
         logic_or__3,
         logic_or__4,
         logic_or__5,
         logic_or__6,
         lookupvector,
         lpIn__0,
         lpIn__1,
         lpIn__10,
         lpIn__11,
         lpIn__12,
         lpIn__13,
         lpIn__14,
         lpIn__15,
         lpIn__16,
         lpIn__17,
         lpIn__18,
         lpIn__19,
         lpIn__2,
         lpIn__20,
         lpIn__3,
         lpIn__4,
         lpIn__5,
         lpIn__6,
         lpIn__7,
         lpIn__8,
         lpIn__9,
         lpOut__0,
         lpOut__1,
         lpOut__10,
         lpOut__11,
         lpOut__12,
         lpOut__13,
         lpOut__14,
         lpOut__2,
         lpOut__3,
         lpOut__4,
         lpOut__5,
         lpOut__6,
         lpOut__7,
         lpOut__8,
         lpOut__9,
         lpStruct__0,
         lpStruct__1,
         matrix_expand__0,
         matrix_expand__1,
         matrix_expand__2,
         matrix_expand__3,
         mayerIn__0,
         mayerIn__1,
         mayerIn__2,
         mayerIn__3,
         mayerIn__4,
         mayerIn__5,
         mayerIn__6,
         mayerIn__7,
         mayerIn__8,
         mtaylor__0,
         mtaylor__1,
         mtaylor__2,
         mul__0,
         mul__1,
         mul__10,
         mul__11,
         mul__12,
         mul__2,
         mul__3,
         mul__4,
         mul__5,
         mul__6,
         mul__7,
         mul__8,
         mul__9,
         nlpIn__0,
         nlpIn__1,
         nlpIn__2,
         nlpIn__3,
         nlpIn__4,
         nlpIn__5,
         nlpIn__6,
         nlpIn__7,
         nlpIn__8,
         nlpOut__0,
         nlpOut__1,
         nlpOut__2,
         nlpOut__3,
         nlpOut__4,
         nlpOut__5,
         nlpOut__6,
         nlpOut__7,
         nlpOut__8,
         nlpSolverIn__0,
         nlpSolverIn__1,
         nlpSolverIn__10,
         nlpSolverIn__11,
         nlpSolverIn__12,
         nlpSolverIn__13,
         nlpSolverIn__14,
         nlpSolverIn__15,
         nlpSolverIn__16,
         nlpSolverIn__17,
         nlpSolverIn__18,
         nlpSolverIn__19,
         nlpSolverIn__2,
         nlpSolverIn__20,
         nlpSolverIn__21,
         nlpSolverIn__22,
         nlpSolverIn__23,
         nlpSolverIn__24,
         nlpSolverIn__25,
         nlpSolverIn__26,
         nlpSolverIn__3,
         nlpSolverIn__4,
         nlpSolverIn__5,
         nlpSolverIn__6,
         nlpSolverIn__7,
         nlpSolverIn__8,
         nlpSolverIn__9,
         nlpSolverOut__0,
         nlpSolverOut__1,
         nlpSolverOut__10,
         nlpSolverOut__11,
         nlpSolverOut__12,
         nlpSolverOut__13,
         nlpSolverOut__14,
         nlpSolverOut__15,
         nlpSolverOut__16,
         nlpSolverOut__17,
         nlpSolverOut__18,
         nlpSolverOut__19,
         nlpSolverOut__2,
         nlpSolverOut__20,
         nlpSolverOut__3,
         nlpSolverOut__4,
         nlpSolverOut__5,
         nlpSolverOut__6,
         nlpSolverOut__7,
         nlpSolverOut__8,
         nlpSolverOut__9,
         norm_1__0,
         norm_1__1,
         norm_1__2,
         norm_1__3,
         norm_2__0,
         norm_2__1,
         norm_2__2,
         norm_2__3,
         norm_F__0,
         norm_F__1,
         norm_F__2,
         norm_F__3,
         norm_inf__0,
         norm_inf__1,
         norm_inf__2,
         norm_inf__3,
         nullspace__0,
         nullspace__1,
         nullspace__2,
         nullspace__3,
         ocpIn__0,
         ocpIn__1,
         ocpIn__10,
         ocpIn__11,
         ocpIn__12,
         ocpIn__13,
         ocpIn__14,
         ocpIn__15,
         ocpIn__16,
         ocpIn__17,
         ocpIn__18,
         ocpIn__19,
         ocpIn__2,
         ocpIn__20,
         ocpIn__21,
         ocpIn__22,
         ocpIn__23,
         ocpIn__24,
         ocpIn__25,
         ocpIn__26,
         ocpIn__27,
         ocpIn__28,
         ocpIn__29,
         ocpIn__3,
         ocpIn__30,
         ocpIn__31,
         ocpIn__32,
         ocpIn__33,
         ocpIn__34,
         ocpIn__35,
         ocpIn__36,
         ocpIn__37,
         ocpIn__38,
         ocpIn__39,
         ocpIn__4,
         ocpIn__40,
         ocpIn__41,
         ocpIn__5,
         ocpIn__6,
         ocpIn__7,
         ocpIn__8,
         ocpIn__9,
         ocpOut__0,
         ocpOut__1,
         ocpOut__10,
         ocpOut__11,
         ocpOut__12,
         ocpOut__13,
         ocpOut__14,
         ocpOut__2,
         ocpOut__3,
         ocpOut__4,
         ocpOut__5,
         ocpOut__6,
         ocpOut__7,
         ocpOut__8,
         ocpOut__9,
         outer_prod__0,
         outer_prod__1,
         outer_prod__2,
         outer_prod__3,
         pinv__0,
         pinv__1,
         pinv__2,
         pinv__3,
         pinv__4,
         poly_coeff,
         poly_roots,
         polyval__0,
         polyval__1,
         polyval__2,
         polyval__3,
         printCompact__0,
         printCompact__1,
         project__0,
         project__1,
         project__2,
         pw_const,
         pw_lin,
         qcqpIn__0,
         qcqpIn__1,
         qcqpIn__10,
         qcqpIn__11,
         qcqpIn__12,
         qcqpIn__13,
         qcqpIn__14,
         qcqpIn__15,
         qcqpIn__16,
         qcqpIn__17,
         qcqpIn__18,
         qcqpIn__19,
         qcqpIn__2,
         qcqpIn__20,
         qcqpIn__21,
         qcqpIn__22,
         qcqpIn__23,
         qcqpIn__24,
         qcqpIn__25,
         qcqpIn__26,
         qcqpIn__27,
         qcqpIn__28,
         qcqpIn__29,
         qcqpIn__3,
         qcqpIn__30,
         qcqpIn__31,
         qcqpIn__32,
         qcqpIn__33,
         qcqpIn__34,
         qcqpIn__35,
         qcqpIn__36,
         qcqpIn__37,
         qcqpIn__38,
         qcqpIn__4,
         qcqpIn__5,
         qcqpIn__6,
         qcqpIn__7,
         qcqpIn__8,
         qcqpIn__9,
         qcqpOut__0,
         qcqpOut__1,
         qcqpOut__10,
         qcqpOut__11,
         qcqpOut__12,
         qcqpOut__13,
         qcqpOut__14,
         qcqpOut__2,
         qcqpOut__3,
         qcqpOut__4,
         qcqpOut__5,
         qcqpOut__6,
         qcqpOut__7,
         qcqpOut__8,
         qcqpOut__9,
         qcqpStruct__0,
         qcqpStruct__1,
         qcqpStruct__2,
         qcqpStruct__3,
         qpIn__0,
         qpIn__1,
         qpIn__10,
         qpIn__11,
         qpIn__12,
         qpIn__13,
         qpIn__14,
         qpIn__15,
         qpIn__16,
         qpIn__17,
         qpIn__18,
         qpIn__19,
         qpIn__2,
         qpIn__20,
         qpIn__21,
         qpIn__22,
         qpIn__23,
         qpIn__24,
         qpIn__25,
         qpIn__26,
         qpIn__27,
         qpIn__28,
         qpIn__29,
         qpIn__3,
         qpIn__4,
         qpIn__5,
         qpIn__6,
         qpIn__7,
         qpIn__8,
         qpIn__9,
         qpOut__0,
         qpOut__1,
         qpOut__10,
         qpOut__11,
         qpOut__12,
         qpOut__13,
         qpOut__14,
         qpOut__2,
         qpOut__3,
         qpOut__4,
         qpOut__5,
         qpOut__6,
         qpOut__7,
         qpOut__8,
         qpOut__9,
         qpStruct__0,
         qpStruct__1,
         qpStruct__2,
         ramp,
         rank,
         rdaeIn__0,
         rdaeIn__1,
         rdaeIn__10,
         rdaeIn__11,
         rdaeIn__12,
         rdaeIn__13,
         rdaeIn__14,
         rdaeIn__15,
         rdaeIn__16,
         rdaeIn__17,
         rdaeIn__18,
         rdaeIn__19,
         rdaeIn__2,
         rdaeIn__20,
         rdaeIn__21,
         rdaeIn__22,
         rdaeIn__23,
         rdaeIn__3,
         rdaeIn__4,
         rdaeIn__5,
         rdaeIn__6,
         rdaeIn__7,
         rdaeIn__8,
         rdaeIn__9,
         rdaeOut__0,
         rdaeOut__1,
         rdaeOut__10,
         rdaeOut__11,
         rdaeOut__2,
         rdaeOut__3,
         rdaeOut__4,
         rdaeOut__5,
         rdaeOut__6,
         rdaeOut__7,
         rdaeOut__8,
         rdaeOut__9,
         rectangle,
         repmat__0,
         repmat__1,
         repmat__2,
         repmat__3,
         reshape__0,
         reshape__1,
         reshape__2,
         reshape__3,
         reshape__4,
         reshape__5,
         reshape__6,
         reshape__7,
         sdpIn__0,
         sdpIn__1,
         sdpIn__10,
         sdpIn__11,
         sdpIn__12,
         sdpIn__13,
         sdpIn__14,
         sdpIn__15,
         sdpIn__16,
         sdpIn__17,
         sdpIn__18,
         sdpIn__19,
         sdpIn__2,
         sdpIn__20,
         sdpIn__21,
         sdpIn__22,
         sdpIn__23,
         sdpIn__24,
         sdpIn__25,
         sdpIn__26,
         sdpIn__3,
         sdpIn__4,
         sdpIn__5,
         sdpIn__6,
         sdpIn__7,
         sdpIn__8,
         sdpIn__9,
         sdpOut__0,
         sdpOut__1,
         sdpOut__10,
         sdpOut__11,
         sdpOut__12,
         sdpOut__13,
         sdpOut__14,
         sdpOut__15,
         sdpOut__16,
         sdpOut__17,
         sdpOut__18,
         sdpOut__19,
         sdpOut__2,
         sdpOut__20,
         sdpOut__21,
         sdpOut__22,
         sdpOut__23,
         sdpOut__3,
         sdpOut__4,
         sdpOut__5,
         sdpOut__6,
         sdpOut__7,
         sdpOut__8,
         sdpOut__9,
         sdpStruct__0,
         sdpStruct__1,
         sdpStruct__2,
         sdpStruct__3,
         sdqpIn__0,
         sdqpIn__1,
         sdqpIn__10,
         sdqpIn__11,
         sdqpIn__12,
         sdqpIn__13,
         sdqpIn__14,
         sdqpIn__15,
         sdqpIn__16,
         sdqpIn__17,
         sdqpIn__18,
         sdqpIn__19,
         sdqpIn__2,
         sdqpIn__20,
         sdqpIn__21,
         sdqpIn__22,
         sdqpIn__23,
         sdqpIn__24,
         sdqpIn__25,
         sdqpIn__26,
         sdqpIn__27,
         sdqpIn__28,
         sdqpIn__29,
         sdqpIn__3,
         sdqpIn__4,
         sdqpIn__5,
         sdqpIn__6,
         sdqpIn__7,
         sdqpIn__8,
         sdqpIn__9,
         sdqpOut__0,
         sdqpOut__1,
         sdqpOut__10,
         sdqpOut__11,
         sdqpOut__12,
         sdqpOut__13,
         sdqpOut__14,
         sdqpOut__15,
         sdqpOut__16,
         sdqpOut__17,
         sdqpOut__18,
         sdqpOut__19,
         sdqpOut__2,
         sdqpOut__20,
         sdqpOut__21,
         sdqpOut__22,
         sdqpOut__23,
         sdqpOut__3,
         sdqpOut__4,
         sdqpOut__5,
         sdqpOut__6,
         sdqpOut__7,
         sdqpOut__8,
         sdqpOut__9,
         sdqpStruct__0,
         sdqpStruct__1,
         sdqpStruct__2,
         sdqpStruct__3,
         sdqpStruct__4,
         simplify__0,
         simplify__1,
         socpIn__0,
         socpIn__1,
         socpIn__10,
         socpIn__11,
         socpIn__12,
         socpIn__13,
         socpIn__14,
         socpIn__15,
         socpIn__16,
         socpIn__17,
         socpIn__18,
         socpIn__19,
         socpIn__2,
         socpIn__20,
         socpIn__21,
         socpIn__22,
         socpIn__23,
         socpIn__24,
         socpIn__25,
         socpIn__26,
         socpIn__27,
         socpIn__28,
         socpIn__29,
         socpIn__3,
         socpIn__30,
         socpIn__31,
         socpIn__32,
         socpIn__4,
         socpIn__5,
         socpIn__6,
         socpIn__7,
         socpIn__8,
         socpIn__9,
         socpOut__0,
         socpOut__1,
         socpOut__10,
         socpOut__11,
         socpOut__12,
         socpOut__13,
         socpOut__14,
         socpOut__2,
         socpOut__3,
         socpOut__4,
         socpOut__5,
         socpOut__6,
         socpOut__7,
         socpOut__8,
         socpOut__9,
         socpStruct__0,
         socpStruct__1,
         socpStruct__2,
         solve__0,
         solve__1,
         solve__2,
         solve__3,
         solve__4,
         solve__5,
         sparse__0,
         sparse__1,
         sparse__2,
         sparse__3,
         sparse__4,
         sparse__5,
         sprank__0,
         sprank__1,
         sprank__2,
         spy,
         stabilizedQpIn__0,
         stabilizedQpIn__1,
         stabilizedQpIn__10,
         stabilizedQpIn__11,
         stabilizedQpIn__12,
         stabilizedQpIn__13,
         stabilizedQpIn__14,
         stabilizedQpIn__15,
         stabilizedQpIn__16,
         stabilizedQpIn__17,
         stabilizedQpIn__18,
         stabilizedQpIn__19,
         stabilizedQpIn__2,
         stabilizedQpIn__20,
         stabilizedQpIn__21,
         stabilizedQpIn__22,
         stabilizedQpIn__23,
         stabilizedQpIn__24,
         stabilizedQpIn__25,
         stabilizedQpIn__26,
         stabilizedQpIn__27,
         stabilizedQpIn__28,
         stabilizedQpIn__29,
         stabilizedQpIn__3,
         stabilizedQpIn__30,
         stabilizedQpIn__31,
         stabilizedQpIn__32,
         stabilizedQpIn__33,
         stabilizedQpIn__34,
         stabilizedQpIn__35,
         stabilizedQpIn__36,
         stabilizedQpIn__37,
         stabilizedQpIn__38,
         stabilizedQpIn__4,
         stabilizedQpIn__5,
         stabilizedQpIn__6,
         stabilizedQpIn__7,
         stabilizedQpIn__8,
         stabilizedQpIn__9,
         substituteInPlace__0,
         substituteInPlace__1,
         substituteInPlace__2,
         substituteInPlace__3,
         substituteInPlace__4,
         substituteInPlace__5,
         substitute__0,
         substitute__1,
         substitute__2,
         substitute__3,
         sumAll__0,
         sumAll__1,
         sumAll__2,
         sumAll__3,
         sumCols__0,
         sumCols__1,
         sumCols__2,
         sumCols__3,
         sumRows__0,
         sumRows__1,
         sumRows__2,
         sumRows__3,
         tangent__0,
         tangent__1,
         taylor__0,
         taylor__1,
         taylor__2,
         trace__0,
         trace__1,
         trace__2,
         trace__3,
         transpose__0,
         transpose__1,
         transpose__2,
         transpose__3,
         transpose__4,
         triangle,
         tril2symm__0,
         tril2symm__1,
         tril2symm__2,
         tril2symm__3,
         tril__0,
         tril__1,
         tril__2,
         tril__3,
         tril__4,
         tril__5,
         triu2symm__0,
         triu2symm__1,
         triu2symm__2,
         triu2symm__3,
         triu__0,
         triu__1,
         triu__2,
         triu__3,
         triu__4,
         triu__5,
         unite__0,
         unite__1,
         unite__2,
         unite__3,
         vecNZ__0,
         vecNZ__1,
         vecNZ__2,
         vecNZ__3,
         vecNZcat__0,
         vecNZcat__1,
         vecNZcat__2,
         vecNZcat__3,
         vec__0,
         vec__1,
         vec__2,
         vec__3,
         vec__4,
         veccat__0,
         veccat__1,
         veccat__2,
         veccat__3,
         vertcat__0,
         vertcat__1,
         vertcat__2,
         vertcat__3,
         vertcat__4,
         vertsplit__0,
         vertsplit__1,
         vertsplit__10,
         vertsplit__11,
         vertsplit__12,
         vertsplit__2,
         vertsplit__3,
         vertsplit__4,
         vertsplit__5,
         vertsplit__6,
         vertsplit__7,
         vertsplit__8,
         vertsplit__9,
       ) where


import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Marshal ( new, free )
import Foreign.Storable ( peek )
import Foreign.Ptr ( Ptr, nullPtr )

import Casadi.Core.Data
import Casadi.Core.Enums
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString )
import Casadi.Internal.Marshal ( withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )

foreign import ccall unsafe "addMultiple__0" c_addMultiple__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> IO ()
{-|
>same as: res += mul(A, v)
-}
addMultiple__0
  :: SX -> Vector SXElement -> Vector SXElement -> IO ()
addMultiple__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_addMultiple__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "addMultiple__1" c_addMultiple__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> CInt -> IO ()
{-|
>same as: res += mul(A, v)
-}
addMultiple__1
  :: SX -> Vector SXElement -> Vector SXElement -> Bool -> IO ()
addMultiple__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_addMultiple__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "addMultiple__2" c_addMultiple__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> IO ()
{-|
>same as: res += mul(A, v)
-}
addMultiple__2
  :: DMatrix -> Vector Double -> Vector Double -> IO ()
addMultiple__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_addMultiple__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "addMultiple__3" c_addMultiple__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> CInt -> IO ()
{-|
>same as: res += mul(A, v)
-}
addMultiple__3
  :: DMatrix -> Vector Double -> Vector Double -> Bool -> IO ()
addMultiple__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_addMultiple__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "addMultiple__4" c_addMultiple__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
{-|
>same as: res += mul(A, v)
-}
addMultiple__4
  :: IMatrix -> Vector Int -> Vector Int -> IO ()
addMultiple__4 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_addMultiple__4 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "addMultiple__5" c_addMultiple__5
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
{-|
>same as: res += mul(A, v)
-}
addMultiple__5
  :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO ()
addMultiple__5 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_addMultiple__5 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


foreign import ccall unsafe "blkdiag__0" c_blkdiag__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Construct a matrix with given blocks on the diagonal.
-}
blkdiag__0
  :: Vector MX -> IO MX
blkdiag__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blkdiag__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blkdiag__1" c_blkdiag__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
{-|
>Construct a Sparsity with given blocks on the diagonal.
-}
blkdiag__1
  :: Vector Sparsity -> IO Sparsity
blkdiag__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blkdiag__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blkdiag__2" c_blkdiag__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
{-|
>Construct a matrix with given block on the diagonal.
-}
blkdiag__2
  :: Vector SX -> IO SX
blkdiag__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blkdiag__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blkdiag__3" c_blkdiag__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
{-|
>Construct a matrix with given block on the diagonal.
-}
blkdiag__3
  :: Vector DMatrix -> IO DMatrix
blkdiag__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blkdiag__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blkdiag__4" c_blkdiag__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
{-|
>Construct a matrix with given block on the diagonal.
-}
blkdiag__4
  :: Vector IMatrix -> IO IMatrix
blkdiag__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blkdiag__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blockcat__0" c_blockcat__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX')
{-|
>Construct a matrix from a list of list of blocks.
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blockcat__0
  :: Vector (Vector MX) -> IO MX
blockcat__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blockcat__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blockcat__1" c_blockcat__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX')
{-|
>Construct a matrix from a list of list of blocks.
-}
blockcat__1
  :: Vector (Vector SX) -> IO SX
blockcat__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blockcat__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blockcat__2" c_blockcat__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO (Ptr DMatrix')
{-|
>Construct a matrix from a list of list of blocks.
-}
blockcat__2
  :: Vector (Vector DMatrix) -> IO DMatrix
blockcat__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blockcat__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blockcat__3" c_blockcat__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix')
{-|
>Construct a matrix from a list of list of blocks.
-}
blockcat__3
  :: Vector (Vector IMatrix) -> IO IMatrix
blockcat__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blockcat__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__0" c_blocksplit__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in col dimension
>horz_incr Defines the increment for block boundaries in row dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__0
  :: MX -> IO (Vector (Vector MX))
blocksplit__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__1" c_blocksplit__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in col dimension
>horz_incr Defines the increment for block boundaries in row dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__1
  :: MX -> Int -> IO (Vector (Vector MX))
blocksplit__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__2" c_blocksplit__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in col dimension
>horz_incr Defines the increment for block boundaries in row dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__2
  :: MX -> Int -> Int -> IO (Vector (Vector MX))
blocksplit__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__3" c_blocksplit__3
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
{-|
>chop up into blocks
>
>vert_offset Defines the boundaries of the block cols horz_offset Defines the
>boundaries of the block rows
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__3
  :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX))
blocksplit__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__4" c_blocksplit__4
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__4
  :: SX -> IO (Vector (Vector SX))
blocksplit__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__5" c_blocksplit__5
  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__5
  :: SX -> Int -> IO (Vector (Vector SX))
blocksplit__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__6" c_blocksplit__6
  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__6
  :: SX -> Int -> Int -> IO (Vector (Vector SX))
blocksplit__6 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__6 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__7" c_blocksplit__7
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
{-|
>chop up into blocks
>
>vert_offset Defines the boundaries of the block rows horz_offset Defines the
>boundaries of the block columns
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__7
  :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX))
blocksplit__7 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__7 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__8" c_blocksplit__8
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__8
  :: DMatrix -> IO (Vector (Vector DMatrix))
blocksplit__8 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__8 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__9" c_blocksplit__9
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__9
  :: DMatrix -> Int -> IO (Vector (Vector DMatrix))
blocksplit__9 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__9 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__10" c_blocksplit__10
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__10
  :: DMatrix -> Int -> Int -> IO (Vector (Vector DMatrix))
blocksplit__10 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__10 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__11" c_blocksplit__11
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
{-|
>chop up into blocks
>
>vert_offset Defines the boundaries of the block rows horz_offset Defines the
>boundaries of the block columns
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__11
  :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix))
blocksplit__11 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__11 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__12" c_blocksplit__12
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__12
  :: IMatrix -> IO (Vector (Vector IMatrix))
blocksplit__12 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__12 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__13" c_blocksplit__13
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__13
  :: IMatrix -> Int -> IO (Vector (Vector IMatrix))
blocksplit__13 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__13 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__14" c_blocksplit__14
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
{-|
>chop up into blocks
>
>vert_incr Defines the increment for block boundaries in row dimension
>horz_incr Defines the increment for block boundaries in column dimension
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__14
  :: IMatrix -> Int -> Int -> IO (Vector (Vector IMatrix))
blocksplit__14 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__14 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "blocksplit__15" c_blocksplit__15
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
{-|
>chop up into blocks
>
>vert_offset Defines the boundaries of the block rows horz_offset Defines the
>boundaries of the block columns
>
>blockcat(blocksplit(x,..., ...)) = x
-}
blocksplit__15
  :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix))
blocksplit__15 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_blocksplit__15 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


foreign import ccall unsafe "collocationPoints__0" c_collocationPoints__0
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble))
{-|
>Obtain collocation points of specific order and scheme.
>
>Parameters:
>-----------
>
>scheme:  'radau' or 'legendre'
-}
collocationPoints__0
  :: Int -> IO (Vector Double)
collocationPoints__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_collocationPoints__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "collocationPoints__1" c_collocationPoints__1
  :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO (Ptr (StdVec CDouble))
{-|
>Obtain collocation points of specific order and scheme.
>
>Parameters:
>-----------
>
>scheme:  'radau' or 'legendre'
-}
collocationPoints__1
  :: Int -> String -> IO (Vector Double)
collocationPoints__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_collocationPoints__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "complement" c_complement
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
{-|
>Returns the list of all i in [0, size[ not found in supplied list.
>
>The supplied vector may contain duplicates and may be non-monotonous The
>supplied vector will be checked for bounds The result vector is guaranteed
>to be monotonously increasing
-}
complement
  :: Vector Int -> Int -> IO (Vector Int)
complement x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_complement errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "compress__0" c_compress__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
{-|
>Remove identical calculations.
-}
compress__0
  :: SX -> IO ()
compress__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_compress__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "compress__1" c_compress__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
{-|
>Remove identical calculations.
-}
compress__1
  :: SX -> Int -> IO ()
compress__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_compress__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "controldaeIn__4" c_controldaeIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
controldaeIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
controldaeIn__4 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_controldaeIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__5" c_controldaeIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
controldaeIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
controldaeIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__6" c_controldaeIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
controldaeIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
controldaeIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__7" c_controldaeIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
controldaeIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
controldaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__8" c_controldaeIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
controldaeIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
controldaeIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__9" c_controldaeIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
controldaeIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
controldaeIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


foreign import ccall unsafe "controldaeIn__15" c_controldaeIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
controldaeIn__15
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
controldaeIn__15 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__15 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__16" c_controldaeIn__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
controldaeIn__16
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
controldaeIn__16 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__17" c_controldaeIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
controldaeIn__17
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
controldaeIn__17 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__18" c_controldaeIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
controldaeIn__18
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
controldaeIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__19" c_controldaeIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
controldaeIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
controldaeIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "controldaeIn__24" c_controldaeIn__24
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
controldaeIn__24
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
controldaeIn__24 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_controldaeIn__24 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "controldaeIn__27" c_controldaeIn__27
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
controldaeIn__27
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
controldaeIn__27 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__28" c_controldaeIn__28
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
controldaeIn__28
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
controldaeIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "controldaeIn__29" c_controldaeIn__29
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
controldaeIn__29
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
controldaeIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_controldaeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "countNodes__0" c_countNodes__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
{-|
>Count number of nodes
-}
countNodes__0
  :: MX -> IO Int
countNodes__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_countNodes__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "countNodes__1" c_countNodes__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
{-|
>Count number of nodes.
-}
countNodes__1
  :: SX -> IO Int
countNodes__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_countNodes__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "createParent__0" c_createParent__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Create a parent MX on which a bunch of MX's (sizes given as argument) will
>depend.
-}
createParent__0
  :: Vector Sparsity -> Vector MX -> IO MX
createParent__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_createParent__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "createParent__1" c_createParent__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Create a parent MX on which a bunch of MX's (sizes given as argument) will
>depend.
-}
createParent__1
  :: Vector MX -> Vector MX -> IO MX
createParent__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_createParent__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "createParent__2" c_createParent__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Create a parent MX on which all given MX's will depend.
>
>In some sense, this function is the inverse of
>
>Parameters:
>-----------
>
>deps:  Must all be symbolic matrices.
-}
createParent__2
  :: Vector MX -> IO MX
createParent__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_createParent__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__0" c_cross__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Matlab's cross command.
-}
cross__0
  :: MX -> MX -> IO MX
cross__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__1" c_cross__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
{-|
>Matlab's cross command.
-}
cross__1
  :: MX -> MX -> Int -> IO MX
cross__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__2" c_cross__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Matlab's cross command.
-}
cross__2
  :: SX -> SX -> IO SX
cross__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__3" c_cross__3
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
{-|
>Matlab's cross command.
-}
cross__3
  :: SX -> SX -> Int -> IO SX
cross__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__4" c_cross__4
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Matlab's cross command.
-}
cross__4
  :: DMatrix -> DMatrix -> IO DMatrix
cross__4 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__4 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__5" c_cross__5
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
{-|
>Matlab's cross command.
-}
cross__5
  :: DMatrix -> DMatrix -> Int -> IO DMatrix
cross__5 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__5 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__6" c_cross__6
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Matlab's cross command.
-}
cross__6
  :: IMatrix -> IMatrix -> IO IMatrix
cross__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "cross__7" c_cross__7
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
{-|
>Matlab's cross command.
-}
cross__7
  :: IMatrix -> IMatrix -> Int -> IO IMatrix
cross__7 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_cross__7 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "daeIn__4" c_daeIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
daeIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
daeIn__4 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_daeIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "dense__0" c_dense__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>create a clipped view into a matrix Create a sparse matrix from a dense
>matrix A, with sparsity pattern sp
>
>MX clip(const MX& A, const Sparsity& sp) { Join the sparsity patterns
>std::vector<int> mapping; Sparsity sp = A.sparsity().patternIntersection(sp,
>mapping);
>
>Split up the mapping std::vector<int> nzA, nzB;
>
>Copy sparsity for (int k=0; k<mapping.size(); ++k) { if (mapping[k]<0) {
>nzA.push_back(k); } else if (mapping[k]>0) { nzB.push_back(k); } else {
>throw CasadiException("Pattern intersection not empty"); } }
>
>Create mapping MX ret; ret.assignNode(new Mapping(sp)); ret->assign(A,
>range(nzA.size()), nzA); ret->assign(B, range(nzB.size()), nzB); return ret;
>
>}
>
>Make the matrix dense if not already
-}
dense__0
  :: MX -> IO MX
dense__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_dense__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "dense__1" c_dense__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Make a matrix dense.
-}
dense__1
  :: SX -> IO SX
dense__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_dense__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "dense__2" c_dense__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Make a matrix dense.
-}
dense__2
  :: DMatrix -> IO DMatrix
dense__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_dense__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "dense__3" c_dense__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Make a matrix dense.
-}
dense__3
  :: IMatrix -> IO IMatrix
dense__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_dense__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "dependsOn__0" c_dependsOn__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO CInt
{-|
>Check if expression depends on any of the arguments The arguments must be
>symbolic.
-}
dependsOn__0
  :: MX -> Vector MX -> IO Bool
dependsOn__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_dependsOn__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "dependsOn__1" c_dependsOn__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
{-|
>Check if expression depends on the argument The argument must be symbolic.
-}
dependsOn__1
  :: SX -> SX -> IO Bool
dependsOn__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_dependsOn__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "det__0" c_det__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Matrix determinant (experimental)
-}
det__0
  :: MX -> IO MX
det__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_det__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


foreign import ccall unsafe "diag__0" c_diag__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Get the diagonal of a matrix or construct a diagonal.
>
>When the input is square, the diagonal elements are returned. If the input
>is vector-like, a diagonal matrix is constructed with it.
-}
diag__0
  :: MX -> IO MX
diag__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_diag__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "diag__1" c_diag__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Get the diagonal of a matrix or construct a diagonal When the input is
>square, the diagonal elements are returned. If the input is vector- like, a
>diagonal matrix is constructed with it.
-}
diag__1
  :: SX -> IO SX
diag__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_diag__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "diag__2" c_diag__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Get the diagonal of a matrix or construct a diagonal When the input is
>square, the diagonal elements are returned. If the input is vector- like, a
>diagonal matrix is constructed with it.
-}
diag__2
  :: DMatrix -> IO DMatrix
diag__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_diag__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "diag__3" c_diag__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Get the diagonal of a matrix or construct a diagonal When the input is
>square, the diagonal elements are returned. If the input is vector- like, a
>diagonal matrix is constructed with it.
-}
diag__3
  :: IMatrix -> IO IMatrix
diag__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_diag__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "eig_symbolic" c_eig_symbolic
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Attempts to find the eigenvalues of a symbolic matrix This will only work
>for up to 3x3 matrices.
>
>Bring m in block diagonal form, calculating eigenvalues of each block
>seperately 
-}
eig_symbolic
  :: SX -> IO SX
eig_symbolic x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_eig_symbolic errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "evalf__0" c_evalf__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Substitute variable v with value vdef in an expression ex, and evaluate
>numerically Note: this is not efficient. For critical parts (loops) of your
>code, always use SXFunction.
-}
evalf__0
  :: SX -> SX -> DMatrix -> IO DMatrix
evalf__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_evalf__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "evalf__1" c_evalf__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr DMatrix')
{-|
>Evaluate an SX graph numerically Note: this is not efficient. For critical
>parts (loops) of your code, always use SXFunction.
-}
evalf__1
  :: SX -> IO DMatrix
evalf__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_evalf__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "expand" c_expand
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
{-|
>Expand the expression as a weighted sum (with constant weights)
-}
expand
  :: SX -> SX -> SX -> IO ()
expand x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_expand errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "explicitRK__0" c_explicitRK__0
  :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
{-|
>Construct an explicit Runge-Kutta integrator.
>
>Parameters:
>-----------
>
>f:  dynamical system
>
>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
>+-----------+-------+----------------------------+
>| Full name | Short |        Description         |
>+===========+=======+============================+
>| DAE_X     | x     | Differential state .       |
>+-----------+-------+----------------------------+
>| DAE_Z     | z     | Algebraic state .          |
>+-----------+-------+----------------------------+
>| DAE_P     | p     | Parameter .                |
>+-----------+-------+----------------------------+
>| DAE_T     | t     | Explicit time dependence . |
>+-----------+-------+----------------------------+
>
>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
>+-----------+-------+--------------------------------------------+
>| Full name | Short |                Description                 |
>+===========+=======+============================================+
>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
>+-----------+-------+--------------------------------------------+
>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
>+-----------+-------+--------------------------------------------+
>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
>+-----------+-------+--------------------------------------------+
>
>Parameters:
>-----------
>
>tf:  Integration end time
>
>order:  Order of integration
>
>ne:  Number of times the RK primitive is repeated over the integration
>interval
-}
explicitRK__0
  :: Function -> IO Function
explicitRK__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_explicitRK__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "explicitRK__1" c_explicitRK__1
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> IO (Ptr Function')
{-|
>Construct an explicit Runge-Kutta integrator.
>
>Parameters:
>-----------
>
>f:  dynamical system
>
>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
>+-----------+-------+----------------------------+
>| Full name | Short |        Description         |
>+===========+=======+============================+
>| DAE_X     | x     | Differential state .       |
>+-----------+-------+----------------------------+
>| DAE_Z     | z     | Algebraic state .          |
>+-----------+-------+----------------------------+
>| DAE_P     | p     | Parameter .                |
>+-----------+-------+----------------------------+
>| DAE_T     | t     | Explicit time dependence . |
>+-----------+-------+----------------------------+
>
>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
>+-----------+-------+--------------------------------------------+
>| Full name | Short |                Description                 |
>+===========+=======+============================================+
>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
>+-----------+-------+--------------------------------------------+
>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
>+-----------+-------+--------------------------------------------+
>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
>+-----------+-------+--------------------------------------------+
>
>Parameters:
>-----------
>
>tf:  Integration end time
>
>order:  Order of integration
>
>ne:  Number of times the RK primitive is repeated over the integration
>interval
-}
explicitRK__1
  :: Function -> MX -> IO Function
explicitRK__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_explicitRK__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "explicitRK__2" c_explicitRK__2
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> IO (Ptr Function')
{-|
>Construct an explicit Runge-Kutta integrator.
>
>Parameters:
>-----------
>
>f:  dynamical system
>
>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
>+-----------+-------+----------------------------+
>| Full name | Short |        Description         |
>+===========+=======+============================+
>| DAE_X     | x     | Differential state .       |
>+-----------+-------+----------------------------+
>| DAE_Z     | z     | Algebraic state .          |
>+-----------+-------+----------------------------+
>| DAE_P     | p     | Parameter .                |
>+-----------+-------+----------------------------+
>| DAE_T     | t     | Explicit time dependence . |
>+-----------+-------+----------------------------+
>
>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
>+-----------+-------+--------------------------------------------+
>| Full name | Short |                Description                 |
>+===========+=======+============================================+
>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
>+-----------+-------+--------------------------------------------+
>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
>+-----------+-------+--------------------------------------------+
>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
>+-----------+-------+--------------------------------------------+
>
>Parameters:
>-----------
>
>tf:  Integration end time
>
>order:  Order of integration
>
>ne:  Number of times the RK primitive is repeated over the integration
>interval
-}
explicitRK__2
  :: Function -> MX -> Int -> IO Function
explicitRK__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_explicitRK__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "explicitRK__3" c_explicitRK__3
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> CInt -> IO (Ptr Function')
{-|
>Construct an explicit Runge-Kutta integrator.
>
>Parameters:
>-----------
>
>f:  dynamical system
>
>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
>+-----------+-------+----------------------------+
>| Full name | Short |        Description         |
>+===========+=======+============================+
>| DAE_X     | x     | Differential state .       |
>+-----------+-------+----------------------------+
>| DAE_Z     | z     | Algebraic state .          |
>+-----------+-------+----------------------------+
>| DAE_P     | p     | Parameter .                |
>+-----------+-------+----------------------------+
>| DAE_T     | t     | Explicit time dependence . |
>+-----------+-------+----------------------------+
>
>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
>+-----------+-------+--------------------------------------------+
>| Full name | Short |                Description                 |
>+===========+=======+============================================+
>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
>+-----------+-------+--------------------------------------------+
>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
>+-----------+-------+--------------------------------------------+
>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
>+-----------+-------+--------------------------------------------+
>
>Parameters:
>-----------
>
>tf:  Integration end time
>
>order:  Order of integration
>
>ne:  Number of times the RK primitive is repeated over the integration
>interval
-}
explicitRK__3
  :: Function -> MX -> Int -> Int -> IO Function
explicitRK__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_explicitRK__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "extractShared__0" c_extractShared__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
{-|
>Extract shared subexpressions from an set of expressions.
-}
extractShared__0
  :: Vector MX -> Vector MX -> Vector MX -> IO ()
extractShared__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_extractShared__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "extractShared__1" c_extractShared__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO ()
{-|
>Extract shared subexpressions from an set of expressions.
-}
extractShared__1
  :: Vector MX -> Vector MX -> Vector MX -> String -> IO ()
extractShared__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_extractShared__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "extractShared__2" c_extractShared__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO ()
{-|
>Extract shared subexpressions from an set of expressions.
-}
extractShared__2
  :: Vector MX -> Vector MX -> Vector MX -> String -> String -> IO ()
extractShared__2 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_extractShared__2 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "extractShared__3" c_extractShared__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> IO ()
{-|
>Extract shared subexpressions from an set of expressions.
-}
extractShared__3
  :: Vector SXElement -> Vector SXElement -> Vector SXElement -> IO ()
extractShared__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_extractShared__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "extractShared__4" c_extractShared__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr StdString -> IO ()
{-|
>Extract shared subexpressions from an set of expressions.
-}
extractShared__4
  :: Vector SXElement -> Vector SXElement -> Vector SXElement -> String -> IO ()
extractShared__4 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_extractShared__4 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "extractShared__5" c_extractShared__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr StdString -> Ptr StdString -> IO ()
{-|
>Extract shared subexpressions from an set of expressions.
-}
extractShared__5
  :: Vector SXElement -> Vector SXElement -> Vector SXElement -> String -> String -> IO ()
extractShared__5 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_extractShared__5 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "gauss_quadrature__0" c_gauss_quadrature__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
gauss_quadrature__0
  :: SX -> SX -> SX -> SX -> IO SX
gauss_quadrature__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "gauss_quadrature__1" c_gauss_quadrature__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
gauss_quadrature__1
  :: SX -> SX -> SX -> SX -> Int -> IO SX
gauss_quadrature__1 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_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "gauss_quadrature__2" c_gauss_quadrature__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr SX' -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
gauss_quadrature__2
  :: SX -> SX -> SX -> SX -> Int -> SX -> IO SX
gauss_quadrature__2 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "getFree" c_getFree
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Get all the free variables in an expression.
-}
getFree
  :: SX -> IO SX
getFree x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_getFree errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


foreign import ccall unsafe "getOperatorRepresentation__0" c_getOperatorRepresentation__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
{-|
>Get a string representation for a binary MX, using custom arguments.
-}
getOperatorRepresentation__0
  :: MX -> Vector String -> IO String
getOperatorRepresentation__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_getOperatorRepresentation__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "getOperatorRepresentation__1" c_getOperatorRepresentation__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
{-|
>Get a string representation for a binary SX, using custom arguments.
-}
getOperatorRepresentation__1
  :: SXElement -> Vector String -> IO String
getOperatorRepresentation__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_getOperatorRepresentation__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


foreign import ccall unsafe "getSymbols__0" c_getSymbols__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>Get all symbols contained in the supplied expression Get all symbols on
>which the supplied expression depends.
>
>See:   MXFunction::getFree()
-}
getSymbols__0
  :: Vector MX -> IO (Vector MX)
getSymbols__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_getSymbols__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "getSymbols__1" c_getSymbols__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
{-|
>Get all symbols contained in the supplied expression Get all symbols on
>which the supplied expression depends.
>
>See:   MXFunction::getFree()
-}
getSymbols__1
  :: MX -> IO (Vector MX)
getSymbols__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_getSymbols__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "getSymbols__2" c_getSymbols__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SXElement')))
{-|
>Get all symbols contained in the supplied expression Get all symbols on
>which the supplied expression depends.
>
>See:   SXFunction::getFree()
-}
getSymbols__2
  :: SX -> IO (Vector SXElement)
getSymbols__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_getSymbols__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "gradient__0" c_gradient__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>split vertically, retaining groups of cols
>
>Parameters:
>-----------
>
>output_offset:  List of all start cols for each group the last col group
>will run to the end.
>
>horzcat(horzsplit(x, ...)) = x
-}
gradient__0
  :: MX -> MX -> IO MX
gradient__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_gradient__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "gradient__1" c_gradient__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
gradient__1
  :: SX -> SX -> IO SX
gradient__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_gradient__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "graph_substitute__0" c_graph_substitute__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>Substitute variable var with expression expr in multiple expressions,
>preserving nodes.
-}
graph_substitute__0
  :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
graph_substitute__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_graph_substitute__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "graph_substitute__1" c_graph_substitute__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Substitute variable v with expression vdef in an expression ex, preserving
>nodes.
-}
graph_substitute__1
  :: MX -> Vector MX -> Vector MX -> IO MX
graph_substitute__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_graph_substitute__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "heaviside" c_heaviside
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Heaviside function.
>
>\\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \\\\\\\\
>H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]
-}
heaviside
  :: SX -> IO SX
heaviside x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_heaviside errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "hessLagIn__4" c_hessLagIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
hessLagIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
hessLagIn__4 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_hessLagIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "hessLagOut__4" c_hessLagOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
hessLagOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
hessLagOut__4 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_hessLagOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "hessLagOut__5" c_hessLagOut__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
hessLagOut__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
hessLagOut__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_hessLagOut__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "hessLagOut__10" c_hessLagOut__10
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
hessLagOut__10
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
hessLagOut__10 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_hessLagOut__10 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "hessLagOut__11" c_hessLagOut__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
hessLagOut__11
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
hessLagOut__11 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_hessLagOut__11 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "hessLagOut__16" c_hessLagOut__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
hessLagOut__16
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
hessLagOut__16 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_hessLagOut__16 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


foreign import ccall unsafe "hessian__0" c_hessian__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
hessian__0
  :: SX -> SX -> SX -> SX -> IO ()
hessian__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_hessian__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "hessian__1" c_hessian__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
hessian__1
  :: SX -> SX -> IO SX
hessian__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_hessian__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "horzcat__0" c_horzcat__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>concatenate vertically
>
>horzcat(horzsplit(x, ...)) = x
-}
horzcat__0
  :: Vector MX -> IO MX
horzcat__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzcat__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzcat__1" c_horzcat__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
{-|
>Concatenate a list of sparsities horizontally Alternative terminology:
>horizontal stack, hstack, horizontal append, [a b].
-}
horzcat__1
  :: Vector Sparsity -> IO Sparsity
horzcat__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzcat__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzcat__2" c_horzcat__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
{-|
>Concatenate a list of matrices vertically Alternative terminology: vertical
>stack, vstack, vertical append, [a;b].
>
>horzcat(horzsplit(x, ...)) = x
-}
horzcat__2
  :: Vector SX -> IO SX
horzcat__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzcat__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzcat__3" c_horzcat__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
{-|
>Concatenate a list of matrices vertically Alternative terminology: vertical
>stack, vstack, vertical append, [a;b].
>
>horzcat(horzsplit(x, ...)) = x
-}
horzcat__3
  :: Vector DMatrix -> IO DMatrix
horzcat__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzcat__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzcat__4" c_horzcat__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
{-|
>Concatenate a list of matrices vertically Alternative terminology: vertical
>stack, vstack, vertical append, [a;b].
>
>horzcat(horzsplit(x, ...)) = x
-}
horzcat__4
  :: Vector IMatrix -> IO IMatrix
horzcat__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzcat__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__0" c_horzsplit__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__0
  :: MX -> IO (Vector MX)
horzsplit__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__1" c_horzsplit__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__1
  :: MX -> Int -> IO (Vector MX)
horzsplit__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__2" c_horzsplit__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>split vertically, retaining groups of cols
>
>Parameters:
>-----------
>
>output_offset:  List of all start cols for each group the last col group
>will run to the end.
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__2
  :: MX -> Vector Int -> IO (Vector MX)
horzsplit__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__3" c_horzsplit__3
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
{-|
>Split up a sparsity pattern horizontally.
-}
horzsplit__3
  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
horzsplit__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__4" c_horzsplit__4
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__4
  :: SX -> IO (Vector SX)
horzsplit__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__5" c_horzsplit__5
  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__5
  :: SX -> Int -> IO (Vector SX)
horzsplit__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__6" c_horzsplit__6
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
{-|
>split vertically, retaining groups of cols
>
>Parameters:
>-----------
>
>offset:  List of all start cols for each group the last col group will run
>to the end.
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__6
  :: SX -> Vector Int -> IO (Vector SX)
horzsplit__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__7" c_horzsplit__7
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__7
  :: DMatrix -> IO (Vector DMatrix)
horzsplit__7 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__7 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__8" c_horzsplit__8
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__8
  :: DMatrix -> Int -> IO (Vector DMatrix)
horzsplit__8 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__8 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__9" c_horzsplit__9
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
{-|
>split vertically, retaining groups of cols
>
>Parameters:
>-----------
>
>offset:  List of all start cols for each group the last col group will run
>to the end.
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__9
  :: DMatrix -> Vector Int -> IO (Vector DMatrix)
horzsplit__9 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__9 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__10" c_horzsplit__10
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__10
  :: IMatrix -> IO (Vector IMatrix)
horzsplit__10 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__10 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__11" c_horzsplit__11
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
{-|
>split vertically, retaining fixed-sized groups of cols
>
>Parameters:
>-----------
>
>incr:  Size of each group of cols
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__11
  :: IMatrix -> Int -> IO (Vector IMatrix)
horzsplit__11 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__11 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "horzsplit__12" c_horzsplit__12
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
{-|
>split vertically, retaining groups of cols
>
>Parameters:
>-----------
>
>offset:  List of all start cols for each group the last col group will run
>to the end.
>
>horzcat(horzsplit(x, ...)) = x
-}
horzsplit__12
  :: IMatrix -> Vector Int -> IO (Vector IMatrix)
horzsplit__12 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_horzsplit__12 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "if_else__0" c_if_else__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Branching on MX nodes Ternary operator, "cond ? if_true : if_false".
-}
if_else__0
  :: MX -> MX -> MX -> IO MX
if_else__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_if_else__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "if_else__1" c_if_else__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
if_else__1
  :: SX -> SX -> SX -> IO SX
if_else__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_if_else__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "implicitRK" c_implicitRK
  :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
{-|
>Construct an implicit Runge-Kutta integrator.
>
>Parameters:
>-----------
>
>f:  dynamical system
>
>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 5) [daeIn]
>+-----------+-------+----------------------------+
>| Full name | Short |        Description         |
>+===========+=======+============================+
>| DAE_X     | x     | Differential state .       |
>+-----------+-------+----------------------------+
>| DAE_Z     | z     | Algebraic state .          |
>+-----------+-------+----------------------------+
>| DAE_P     | p     | Parameter .                |
>+-----------+-------+----------------------------+
>| DAE_T     | t     | Explicit time dependence . |
>+-----------+-------+----------------------------+
>
>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]
>+-----------+-------+--------------------------------------------+
>| Full name | Short |                Description                 |
>+===========+=======+============================================+
>| DAE_ODE   | ode   | Right hand side of the implicit ODE .      |
>+-----------+-------+--------------------------------------------+
>| DAE_ALG   | alg   | Right hand side of algebraic equations .   |
>+-----------+-------+--------------------------------------------+
>| DAE_QUAD  | quad  | Right hand side of quadratures equations . |
>+-----------+-------+--------------------------------------------+
>
>Parameters:
>-----------
>
>tf:  Integration end time
>
>order:  Order of integration
>
>scheme:  Collocation scheme, as excepted by collocationPoints function.
>
>ne:  Number of times the RK primitive is repeated over the integration
>interval
-}
implicitRK
  :: Function -> String -> IO Function
implicitRK x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_implicitRK errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "inner_prod__0" c_inner_prod__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Take the inner product of two vectors Equals.
>
>with x and y vectors
-}
inner_prod__0
  :: MX -> MX -> IO MX
inner_prod__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_inner_prod__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "inner_prod__1" c_inner_prod__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Inner product of two matrices Equals.
>
>with x and y matrices of the same dimension
-}
inner_prod__1
  :: SX -> SX -> IO SX
inner_prod__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_inner_prod__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "inner_prod__2" c_inner_prod__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Inner product of two matrices Equals.
>
>with x and y matrices of the same dimension
-}
inner_prod__2
  :: DMatrix -> DMatrix -> IO DMatrix
inner_prod__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_inner_prod__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "inner_prod__3" c_inner_prod__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Inner product of two matrices Equals.
>
>with x and y matrices of the same dimension
-}
inner_prod__3
  :: IMatrix -> IMatrix -> IO IMatrix
inner_prod__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_inner_prod__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "integratorIn__4" c_integratorIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
integratorIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
integratorIn__4 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_integratorIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorIn__5" c_integratorIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
integratorIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
integratorIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorIn__6" c_integratorIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
integratorIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
integratorIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "integratorIn__11" c_integratorIn__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
integratorIn__11
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
integratorIn__11 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_integratorIn__11 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorIn__12" c_integratorIn__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
integratorIn__12
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
integratorIn__12 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorIn__12 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorIn__13" c_integratorIn__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
integratorIn__13
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
integratorIn__13 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "integratorIn__18" c_integratorIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
integratorIn__18
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
integratorIn__18 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_integratorIn__18 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


foreign import ccall unsafe "integratorOut__4" c_integratorOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
integratorOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
integratorOut__4 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_integratorOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorOut__5" c_integratorOut__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
integratorOut__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
integratorOut__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorOut__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorOut__6" c_integratorOut__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
integratorOut__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
integratorOut__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "integratorOut__11" c_integratorOut__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
integratorOut__11
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
integratorOut__11 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_integratorOut__11 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorOut__12" c_integratorOut__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
integratorOut__12
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
integratorOut__12 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorOut__12 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "integratorOut__13" c_integratorOut__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
integratorOut__13
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
integratorOut__13 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_integratorOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "integratorOut__18" c_integratorOut__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
integratorOut__18
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
integratorOut__18 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_integratorOut__18 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "inv__0" c_inv__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Matrix inverse (experimental)
-}
inv__0
  :: MX -> IO MX
inv__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_inv__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


foreign import ccall unsafe "isDecreasing__0" c_isDecreasing__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Check if the vector is strictly decreasing.
-}
isDecreasing__0
  :: Vector Double -> IO Bool
isDecreasing__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isDecreasing__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isDecreasing__1" c_isDecreasing__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Check if the vector is strictly decreasing.
-}
isDecreasing__1
  :: Vector Int -> IO Bool
isDecreasing__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isDecreasing__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isEqual__0" c_isEqual__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
{-|
>Check if two expressions are equal, assuming that they are comparable.
-}
isEqual__0
  :: MX -> MX -> IO Bool
isEqual__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isEqual__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isEqual__1" c_isEqual__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
{-|
>Check if two expressions are equal, assuming that they are comparable.
-}
isEqual__1
  :: SX -> SX -> IO Bool
isEqual__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isEqual__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isEqual__2" c_isEqual__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt
{-|
>Check if two expressions are equal, assuming that they are comparable.
-}
isEqual__2
  :: DMatrix -> DMatrix -> IO Bool
isEqual__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isEqual__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isEqual__3" c_isEqual__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
{-|
>Check if two expressions are equal, assuming that they are comparable.
-}
isEqual__3
  :: IMatrix -> IMatrix -> IO Bool
isEqual__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isEqual__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isIncreasing__0" c_isIncreasing__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Check if the vector is strictly increasing.
-}
isIncreasing__0
  :: Vector Double -> IO Bool
isIncreasing__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isIncreasing__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isIncreasing__1" c_isIncreasing__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Check if the vector is strictly increasing.
-}
isIncreasing__1
  :: Vector Int -> IO Bool
isIncreasing__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isIncreasing__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isMonotone__0" c_isMonotone__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Check if the vector is monotone.
-}
isMonotone__0
  :: Vector Double -> IO Bool
isMonotone__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isMonotone__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isMonotone__1" c_isMonotone__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Check if the vector is monotone.
-}
isMonotone__1
  :: Vector Int -> IO Bool
isMonotone__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isMonotone__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isNonDecreasing__0" c_isNonDecreasing__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Check if the vector is non-decreasing.
-}
isNonDecreasing__0
  :: Vector Double -> IO Bool
isNonDecreasing__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isNonDecreasing__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isNonDecreasing__1" c_isNonDecreasing__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Check if the vector is non-decreasing.
-}
isNonDecreasing__1
  :: Vector Int -> IO Bool
isNonDecreasing__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isNonDecreasing__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isNonIncreasing__0" c_isNonIncreasing__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Check if the vector is non-increasing.
-}
isNonIncreasing__0
  :: Vector Double -> IO Bool
isNonIncreasing__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isNonIncreasing__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isNonIncreasing__1" c_isNonIncreasing__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Check if the vector is non-increasing.
-}
isNonIncreasing__1
  :: Vector Int -> IO Bool
isNonIncreasing__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isNonIncreasing__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isRegular__0" c_isRegular__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Checks if vector does not contain NaN or Inf.
-}
isRegular__0
  :: Vector Double -> IO Bool
isRegular__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isRegular__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isRegular__1" c_isRegular__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Checks if vector does not contain NaN or Inf.
-}
isRegular__1
  :: Vector Int -> IO Bool
isRegular__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isRegular__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isStrictlyMonotone__0" c_isStrictlyMonotone__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt
{-|
>Check if the vector is strictly monotone.
-}
isStrictlyMonotone__0
  :: Vector Double -> IO Bool
isStrictlyMonotone__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isStrictlyMonotone__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "isStrictlyMonotone__1" c_isStrictlyMonotone__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt
{-|
>Check if the vector is strictly monotone.
-}
isStrictlyMonotone__1
  :: Vector Int -> IO Bool
isStrictlyMonotone__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_isStrictlyMonotone__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "jacobian__0" c_jacobian__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Calculate jacobian via source code transformation.
>
>Uses casadi::MXFunction::jac
-}
jacobian__0
  :: MX -> MX -> IO MX
jacobian__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_jacobian__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "jacobian__1" c_jacobian__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Calculate jacobian via source code transformation.
>
>Uses casadi::SXFunction::jac
-}
jacobian__1
  :: SX -> SX -> IO SX
jacobian__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_jacobian__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "jacobianTimesVector__0" c_jacobianTimesVector__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Calculate the Jacobian and multiply by a vector from the left This is
>equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
>transpose_jacobian set to false and true respectively. If contrast to these
>expressions, it will use directional derivatives which is typically (but not
>necessarily) more efficient if the complete Jacobian is not needed and v has
>few rows.
-}
jacobianTimesVector__0
  :: SX -> SX -> SX -> IO SX
jacobianTimesVector__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_jacobianTimesVector__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "jacobianTimesVector__1" c_jacobianTimesVector__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
{-|
>Calculate the Jacobian and multiply by a vector from the left This is
>equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
>transpose_jacobian set to false and true respectively. If contrast to these
>expressions, it will use directional derivatives which is typically (but not
>necessarily) more efficient if the complete Jacobian is not needed and v has
>few rows.
-}
jacobianTimesVector__1
  :: SX -> SX -> SX -> Bool -> IO SX
jacobianTimesVector__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "kron__0" c_kron__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Kronecker tensor product.
>
>Creates a block matrix in which each element (i, j) is a_ij*b
-}
kron__0
  :: MX -> MX -> IO MX
kron__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_kron__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "kron__1" c_kron__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Kronecker tensor product.
>
>Creates a block matrix in which each element (i, j) is a_ij*b
-}
kron__1
  :: SX -> SX -> IO SX
kron__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_kron__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "kron__2" c_kron__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Kronecker tensor product.
>
>Creates a block matrix in which each element (i, j) is a_ij*b
-}
kron__2
  :: DMatrix -> DMatrix -> IO DMatrix
kron__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_kron__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "kron__3" c_kron__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Kronecker tensor product.
>
>Creates a block matrix in which each element (i, j) is a_ij*b
-}
kron__3
  :: IMatrix -> IMatrix -> IO IMatrix
kron__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_kron__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "linspace__0" c_linspace__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
{-|
>Matlab's linspace command.
-}
linspace__0
  :: MX -> MX -> Int -> IO MX
linspace__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_linspace__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "linspace__1" c_linspace__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
{-|
>Matlab's linspace command.
-}
linspace__1
  :: SX -> SX -> Int -> IO SX
linspace__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_linspace__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "linspace__2" c_linspace__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
{-|
>Matlab's linspace command.
-}
linspace__2
  :: DMatrix -> DMatrix -> Int -> IO DMatrix
linspace__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_linspace__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__0" c_logic_and__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__0
  :: SXElement -> SXElement -> IO SXElement
logic_and__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__1" c_logic_and__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__1
  :: MX -> MX -> IO MX
logic_and__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__2" c_logic_and__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__2
  :: SX -> SX -> IO SX
logic_and__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__3" c_logic_and__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__3
  :: DMatrix -> DMatrix -> IO DMatrix
logic_and__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__4" c_logic_and__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__4
  :: IMatrix -> IMatrix -> IO IMatrix
logic_and__4 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__4 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__5" c_logic_and__5
  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__5
  :: Double -> Double -> IO Double
logic_and__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_and__6" c_logic_and__6
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt
{-|
>Logical and, returns (an expression evaluating to) 1 if both expressions are
>nonzero and 0 otherwise.
-}
logic_and__6
  :: Int -> Int -> IO Int
logic_and__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_and__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__0" c_logic_not__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__0
  :: SXElement -> IO SXElement
logic_not__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__1" c_logic_not__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__1
  :: MX -> IO MX
logic_not__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__2" c_logic_not__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__2
  :: SX -> IO SX
logic_not__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__3" c_logic_not__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__3
  :: DMatrix -> IO DMatrix
logic_not__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__4" c_logic_not__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__4
  :: IMatrix -> IO IMatrix
logic_not__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__5" c_logic_not__5
  :: Ptr (Ptr StdString) -> CDouble -> IO CDouble
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__5
  :: Double -> IO Double
logic_not__5 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__5 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_not__6" c_logic_not__6
  :: Ptr (Ptr StdString) -> CInt -> IO CInt
{-|
>Logical not, returns (an expression evaluating to) 1 if expression is zero
>and 0 otherwise.
-}
logic_not__6
  :: Int -> IO Int
logic_not__6 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_not__6 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__0" c_logic_or__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__0
  :: SXElement -> SXElement -> IO SXElement
logic_or__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__1" c_logic_or__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__1
  :: MX -> MX -> IO MX
logic_or__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__2" c_logic_or__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__2
  :: SX -> SX -> IO SX
logic_or__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__3" c_logic_or__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__3
  :: DMatrix -> DMatrix -> IO DMatrix
logic_or__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__4" c_logic_or__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__4
  :: IMatrix -> IMatrix -> IO IMatrix
logic_or__4 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__4 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__5" c_logic_or__5
  :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__5
  :: Double -> Double -> IO Double
logic_or__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "logic_or__6" c_logic_or__6
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt
{-|
>Logical or, returns (an expression evaluating to) 1 if at least one
>expression is nonzero and 0 otherwise.
-}
logic_or__6
  :: Int -> Int -> IO Int
logic_or__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_logic_or__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "lookupvector" c_lookupvector
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
{-|
>Returns a vector for quickly looking up entries of supplied list.
>
>lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v contains
>i
>
>Duplicates are treated by looking up last occurrence
-}
lookupvector
  :: Vector Int -> Int -> IO (Vector Int)
lookupvector x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_lookupvector errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "lpIn__4" c_lpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
lpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
lpIn__4 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_lpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "lpIn__5" c_lpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
lpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
lpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_lpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "lpIn__6" c_lpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
lpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
lpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_lpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "lpIn__11" c_lpIn__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
lpIn__11
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
lpIn__11 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_lpIn__11 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "lpIn__12" c_lpIn__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
lpIn__12
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
lpIn__12 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_lpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "lpIn__13" c_lpIn__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
lpIn__13
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
lpIn__13 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_lpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "lpIn__18" c_lpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
lpIn__18
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
lpIn__18 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_lpIn__18 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


foreign import ccall unsafe "lpOut__4" c_lpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
lpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
lpOut__4 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_lpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "matrix_expand__0" c_matrix_expand__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>Expand MX graph to SXFunction call.
>
>Expand the given expression e, optionally supplying expressions contained in
>it at which expansion should stop.
-}
matrix_expand__0
  :: Vector MX -> IO (Vector MX)
matrix_expand__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_matrix_expand__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "matrix_expand__1" c_matrix_expand__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>Expand MX graph to SXFunction call.
>
>Expand the given expression e, optionally supplying expressions contained in
>it at which expansion should stop.
-}
matrix_expand__1
  :: Vector MX -> Vector MX -> IO (Vector MX)
matrix_expand__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_matrix_expand__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "matrix_expand__2" c_matrix_expand__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Expand MX graph to SXFunction call.
>
>Expand the given expression e, optionally supplying expressions contained in
>it at which expansion should stop.
-}
matrix_expand__2
  :: MX -> IO MX
matrix_expand__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_matrix_expand__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "matrix_expand__3" c_matrix_expand__3
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Expand MX graph to SXFunction call.
>
>Expand the given expression e, optionally supplying expressions contained in
>it at which expansion should stop.
-}
matrix_expand__3
  :: MX -> Vector MX -> IO MX
matrix_expand__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_matrix_expand__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "mtaylor__0" c_mtaylor__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX')
{-|
>multivariate Taylor series expansion
>
>Do Taylor expansions until the aggregated order of a term is equal to
>'order'. The aggregated order of $x^n y^m$ equals $n+m$.
>
>The argument order_contributions can denote how match each variable
>contributes to the aggregated order. If x=[x, y] and order_contributions=[1,
>2], then the aggregated order of $x^n y^m$ equals $1n+2m$.
>
>Example usage
>
>$ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2
>x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $
-}
mtaylor__0
  :: SX -> SX -> SX -> Int -> Vector Int -> IO SX
mtaylor__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_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mtaylor__1" c_mtaylor__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>multivariate Taylor series expansion
>
>Do Taylor expansions until the aggregated order of a term is equal to
>'order'. The aggregated order of $x^n y^m$ equals $n+m$.
-}
mtaylor__1
  :: SX -> SX -> SX -> IO SX
mtaylor__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mtaylor__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mtaylor__2" c_mtaylor__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
{-|
>multivariate Taylor series expansion
>
>Do Taylor expansions until the aggregated order of a term is equal to
>'order'. The aggregated order of $x^n y^m$ equals $n+m$.
-}
mtaylor__2
  :: SX -> SX -> SX -> Int -> IO SX
mtaylor__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mtaylor__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__0" c_mul__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Take the matrix product of n MX objects.
-}
mul__0
  :: Vector MX -> IO MX
mul__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__1" c_mul__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Take the matrix product of 2 MX objects.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient then.
-}
mul__1
  :: MX -> MX -> IO MX
mul__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__2" c_mul__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
{-|
>Take the matrix product of 2 MX objects.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient then.
-}
mul__2
  :: MX -> MX -> Sparsity -> IO MX
mul__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__3" c_mul__3
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
{-|
>Get the sparsity resulting from a matrix multiplication.
-}
mul__3
  :: Sparsity -> Sparsity -> IO Sparsity
mul__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__4" c_mul__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
{-|
>Matrix product of n matrices.
-}
mul__4
  :: Vector SX -> IO SX
mul__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__5" c_mul__5
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Matrix product of two matrices.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient in that case.
-}
mul__5
  :: SX -> SX -> IO SX
mul__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__6" c_mul__6
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
{-|
>Matrix product of two matrices.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient in that case.
-}
mul__6
  :: SX -> SX -> Sparsity -> IO SX
mul__6 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__6 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__7" c_mul__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
{-|
>Matrix product of n matrices.
-}
mul__7
  :: Vector DMatrix -> IO DMatrix
mul__7 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__7 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__8" c_mul__8
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Matrix product of two matrices.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient in that case.
-}
mul__8
  :: DMatrix -> DMatrix -> IO DMatrix
mul__8 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__8 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__9" c_mul__9
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
{-|
>Matrix product of two matrices.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient in that case.
-}
mul__9
  :: DMatrix -> DMatrix -> Sparsity -> IO DMatrix
mul__9 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__9 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__10" c_mul__10
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
{-|
>Matrix product of n matrices.
-}
mul__10
  :: Vector IMatrix -> IO IMatrix
mul__10 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__10 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__11" c_mul__11
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Matrix product of two matrices.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient in that case.
-}
mul__11
  :: IMatrix -> IMatrix -> IO IMatrix
mul__11 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__11 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "mul__12" c_mul__12
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
{-|
>Matrix product of two matrices.
>
>With optional sp_z you can specify the sparsity of the result A typical use
>case might be where the product is only constructed to inspect the trace of
>it. sp_z diagonal will be more efficient in that case.
-}
mul__12
  :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix
mul__12 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_mul__12 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "nlpSolverIn__4" c_nlpSolverIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverIn__4 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_nlpSolverIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__5" c_nlpSolverIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__6" c_nlpSolverIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__7" c_nlpSolverIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__8" c_nlpSolverIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "nlpSolverIn__13" c_nlpSolverIn__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverIn__13
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverIn__13 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_nlpSolverIn__13 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__14" c_nlpSolverIn__14
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverIn__14
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverIn__14 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__14 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__15" c_nlpSolverIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverIn__15
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverIn__15 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__16" c_nlpSolverIn__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverIn__16
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverIn__16 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__17" c_nlpSolverIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverIn__17
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "nlpSolverIn__22" c_nlpSolverIn__22
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
nlpSolverIn__22
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
nlpSolverIn__22 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_nlpSolverIn__22 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "nlpSolverIn__25" c_nlpSolverIn__25
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
nlpSolverIn__25
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
nlpSolverIn__25 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverIn__26" c_nlpSolverIn__26
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
nlpSolverIn__26
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
nlpSolverIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "nlpSolverOut__4" c_nlpSolverOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverOut__4 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_nlpSolverOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverOut__5" c_nlpSolverOut__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverOut__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverOut__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverOut__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverOut__6" c_nlpSolverOut__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
nlpSolverOut__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
nlpSolverOut__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "nlpSolverOut__11" c_nlpSolverOut__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverOut__11
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverOut__11 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_nlpSolverOut__11 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverOut__12" c_nlpSolverOut__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverOut__12
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverOut__12 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverOut__12 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nlpSolverOut__13" c_nlpSolverOut__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
nlpSolverOut__13
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
nlpSolverOut__13 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nlpSolverOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "nlpSolverOut__18" c_nlpSolverOut__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
nlpSolverOut__18
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
nlpSolverOut__18 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_nlpSolverOut__18 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "norm_1__0" c_norm_1__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>1-norm
-}
norm_1__0
  :: MX -> IO MX
norm_1__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_1__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_1__1" c_norm_1__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>1-norm
-}
norm_1__1
  :: SX -> IO SX
norm_1__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_1__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_1__2" c_norm_1__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>1-norm
-}
norm_1__2
  :: DMatrix -> IO DMatrix
norm_1__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_1__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_1__3" c_norm_1__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>1-norm
-}
norm_1__3
  :: IMatrix -> IO IMatrix
norm_1__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_1__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_2__0" c_norm_2__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>2-norm
-}
norm_2__0
  :: MX -> IO MX
norm_2__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_2__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_2__1" c_norm_2__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>2-norm
-}
norm_2__1
  :: SX -> IO SX
norm_2__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_2__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_2__2" c_norm_2__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>2-norm
-}
norm_2__2
  :: DMatrix -> IO DMatrix
norm_2__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_2__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_2__3" c_norm_2__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>2-norm
-}
norm_2__3
  :: IMatrix -> IO IMatrix
norm_2__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_2__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_F__0" c_norm_F__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Frobenius norm.
-}
norm_F__0
  :: MX -> IO MX
norm_F__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_F__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_F__1" c_norm_F__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Frobenius norm.
-}
norm_F__1
  :: SX -> IO SX
norm_F__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_F__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_F__2" c_norm_F__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Frobenius norm.
-}
norm_F__2
  :: DMatrix -> IO DMatrix
norm_F__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_F__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_F__3" c_norm_F__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Frobenius norm.
-}
norm_F__3
  :: IMatrix -> IO IMatrix
norm_F__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_F__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_inf__0" c_norm_inf__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Infinity-norm.
-}
norm_inf__0
  :: MX -> IO MX
norm_inf__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_inf__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_inf__1" c_norm_inf__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Infinity-norm.
-}
norm_inf__1
  :: SX -> IO SX
norm_inf__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_inf__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_inf__2" c_norm_inf__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Infinity-norm.
-}
norm_inf__2
  :: DMatrix -> IO DMatrix
norm_inf__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_inf__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "norm_inf__3" c_norm_inf__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Infinity-norm.
-}
norm_inf__3
  :: IMatrix -> IO IMatrix
norm_inf__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_norm_inf__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nullspace__0" c_nullspace__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Computes the nullspace of a matrix A.
>
>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
>
>Assumes A is full rank
>
>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
-}
nullspace__0
  :: MX -> IO MX
nullspace__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nullspace__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nullspace__1" c_nullspace__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Computes the nullspace of a matrix A.
>
>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
>
>Assumes A is full rank
>
>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
-}
nullspace__1
  :: SX -> IO SX
nullspace__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nullspace__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nullspace__2" c_nullspace__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Computes the nullspace of a matrix A.
>
>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
>
>Assumes A is full rank
>
>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
-}
nullspace__2
  :: DMatrix -> IO DMatrix
nullspace__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nullspace__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "nullspace__3" c_nullspace__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Computes the nullspace of a matrix A.
>
>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
>
>Assumes A is full rank
>
>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
-}
nullspace__3
  :: IMatrix -> IO IMatrix
nullspace__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_nullspace__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "ocpIn__4" c_ocpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__4 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_ocpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__5" c_ocpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__6" c_ocpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__7" c_ocpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__8" c_ocpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__9" c_ocpIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__10" c_ocpIn__10
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__10
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__11" c_ocpIn__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__11
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__12" c_ocpIn__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__12
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__13" c_ocpIn__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpIn__13
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  withMarshal x13 $ \x13' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "ocpIn__18" c_ocpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__18
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__18 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_ocpIn__18 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__19" c_ocpIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__19 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__20" c_ocpIn__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__20
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__20 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__21" c_ocpIn__21
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__21
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__22" c_ocpIn__22
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__22
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__23" c_ocpIn__23
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__23
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__24" c_ocpIn__24
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__24
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__25" c_ocpIn__25
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__25
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__26" c_ocpIn__26
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__26
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__27" c_ocpIn__27
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
ocpIn__27
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
ocpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  withMarshal x13 $ \x13' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "ocpIn__32" c_ocpIn__32
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__32
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__32 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_ocpIn__32 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "ocpIn__35" c_ocpIn__35
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__35
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__36" c_ocpIn__36
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__36
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__37" c_ocpIn__37
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__37
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__38" c_ocpIn__38
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__38
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__39" c_ocpIn__39
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__39
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__40" c_ocpIn__40
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__40
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "ocpIn__41" c_ocpIn__41
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
ocpIn__41
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
ocpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  withMarshal x13 $ \x13' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ocpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "ocpOut__4" c_ocpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
ocpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
ocpOut__4 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_ocpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "outer_prod__0" c_outer_prod__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Take the outer product of two vectors Equals.
>
>with x and y vectors
-}
outer_prod__0
  :: MX -> MX -> IO MX
outer_prod__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_outer_prod__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "outer_prod__1" c_outer_prod__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Outer product of two vectors Equals.
>
>with x and y vectors
-}
outer_prod__1
  :: SX -> SX -> IO SX
outer_prod__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_outer_prod__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "outer_prod__2" c_outer_prod__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Outer product of two vectors Equals.
>
>with x and y vectors
-}
outer_prod__2
  :: DMatrix -> DMatrix -> IO DMatrix
outer_prod__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_outer_prod__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "outer_prod__3" c_outer_prod__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Outer product of two vectors Equals.
>
>with x and y vectors
-}
outer_prod__3
  :: IMatrix -> IMatrix -> IO IMatrix
outer_prod__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_outer_prod__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pinv__0" c_pinv__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
{-|
>Computes the Moore-Penrose pseudo-inverse.
>
>If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
>matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
-}
pinv__0
  :: MX -> String -> IO MX
pinv__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pinv__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pinv__1" c_pinv__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Computes the Moore-Penrose pseudo-inverse.
>
>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
>matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
-}
pinv__1
  :: SX -> IO SX
pinv__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pinv__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pinv__2" c_pinv__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Computes the Moore-Penrose pseudo-inverse.
>
>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
>matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
-}
pinv__2
  :: DMatrix -> IO DMatrix
pinv__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pinv__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pinv__3" c_pinv__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Computes the Moore-Penrose pseudo-inverse.
>
>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
>matrix A is slender (size1<size2), mul(pinv(A), A) is unity.
-}
pinv__3
  :: IMatrix -> IO IMatrix
pinv__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pinv__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pinv__4" c_pinv__4
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')
{-|
>Computes the Moore-Penrose pseudo-inverse.
>
>If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
>matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
-}
pinv__4
  :: DMatrix -> String -> IO DMatrix
pinv__4 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pinv__4 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "poly_coeff" c_poly_coeff
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>extracts polynomial coefficients from an expression
>
>ex Scalar expression that represents a polynomial  x Scalar symbol that the
>polynomial is build up with
-}
poly_coeff
  :: SX -> SX -> IO SX
poly_coeff x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_poly_coeff errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "poly_roots" c_poly_roots
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Attempts to find the roots of a polynomial.
>
>This will only work for polynomials up to order 3 It is assumed that the
>roots are real.
-}
poly_roots
  :: SX -> IO SX
poly_roots x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_poly_roots errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "polyval__0" c_polyval__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Evaluate a polynomial with coefficients p in x.
-}
polyval__0
  :: MX -> MX -> IO MX
polyval__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_polyval__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "polyval__1" c_polyval__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Evaluate a polynomial with coefficients p in x.
-}
polyval__1
  :: SX -> SX -> IO SX
polyval__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_polyval__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "polyval__2" c_polyval__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Evaluate a polynomial with coefficients p in x.
-}
polyval__2
  :: DMatrix -> DMatrix -> IO DMatrix
polyval__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_polyval__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "polyval__3" c_polyval__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Evaluate a polynomial with coefficients p in x.
-}
polyval__3
  :: IMatrix -> IMatrix -> IO IMatrix
polyval__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_polyval__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "printCompact__0" c_printCompact__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
{-|
>Print compact, introducing new variables for shared subexpressions.
-}
printCompact__0
  :: MX -> IO ()
printCompact__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_printCompact__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "printCompact__1" c_printCompact__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
{-|
>Print compact, introducing new variables for shared subexpressions.
-}
printCompact__1
  :: SX -> IO ()
printCompact__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_printCompact__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "project__0" c_project__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
{-|
>Create a new matrix with a given sparsity pattern but with the nonzeros
>taken from an existing matrix.
-}
project__0
  :: SX -> Sparsity -> IO SX
project__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_project__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "project__1" c_project__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
{-|
>Create a new matrix with a given sparsity pattern but with the nonzeros
>taken from an existing matrix.
-}
project__1
  :: DMatrix -> Sparsity -> IO DMatrix
project__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_project__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "project__2" c_project__2
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
{-|
>Create a new matrix with a given sparsity pattern but with the nonzeros
>taken from an existing matrix.
-}
project__2
  :: IMatrix -> Sparsity -> IO IMatrix
project__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_project__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pw_const" c_pw_const
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Create a piecewise constant function Create a piecewise constant function
>with n=val.size() intervals.
>
>Inputs:
>
>Parameters:
>-----------
>
>t:  a scalar variable (e.g. time)
>
>tval:  vector with the discrete values of t at the interval transitions
>(length n-1)
>
>val:  vector with the value of the function for each interval (length n)
-}
pw_const
  :: SX -> SX -> SX -> IO SX
pw_const x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pw_const errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "pw_lin" c_pw_lin
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>t a scalar variable (e.g. time)
>
>Create a piecewise linear function Create a piecewise linear function:
>
>Inputs: tval vector with the the discrete values of t (monotonically
>increasing) val vector with the corresponding function values (same length
>as tval)
-}
pw_lin
  :: SXElement -> SX -> SX -> IO SX
pw_lin x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_pw_lin errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "qcqpIn__4" c_qcqpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__4 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_qcqpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__5" c_qcqpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__6" c_qcqpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__7" c_qcqpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__8" c_qcqpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__9" c_qcqpIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__10" c_qcqpIn__10
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__10
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__11" c_qcqpIn__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__11
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__12" c_qcqpIn__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpIn__12
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "qcqpIn__17" c_qcqpIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__17
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__17 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_qcqpIn__17 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__18" c_qcqpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__18
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__18 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__19" c_qcqpIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__19 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__20" c_qcqpIn__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__20
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__21" c_qcqpIn__21
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__21
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__22" c_qcqpIn__22
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__22
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__23" c_qcqpIn__23
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__23
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__24" c_qcqpIn__24
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__24
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__25" c_qcqpIn__25
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qcqpIn__25
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qcqpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "qcqpIn__30" c_qcqpIn__30
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__30
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__30 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_qcqpIn__30 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "qcqpIn__33" c_qcqpIn__33
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__33
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__34" c_qcqpIn__34
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__34
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__35" c_qcqpIn__35
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__35
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__36" c_qcqpIn__36
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__36
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__37" c_qcqpIn__37
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__37
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qcqpIn__38" c_qcqpIn__38
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qcqpIn__38
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qcqpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qcqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "qcqpOut__4" c_qcqpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qcqpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
qcqpOut__4 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_qcqpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "qpIn__4" c_qpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
qpIn__4 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_qpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__5" c_qpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__6" c_qpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__7" c_qpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__8" c_qpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__9" c_qpIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
qpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


foreign import ccall unsafe "qpIn__15" c_qpIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qpIn__15
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
qpIn__15 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__16" c_qpIn__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qpIn__16
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qpIn__16 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__17" c_qpIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qpIn__17
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__18" c_qpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qpIn__18
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__19" c_qpIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
qpIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
qpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "qpIn__24" c_qpIn__24
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qpIn__24
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
qpIn__24 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_qpIn__24 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "qpIn__27" c_qpIn__27
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qpIn__27
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__28" c_qpIn__28
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qpIn__28
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "qpIn__29" c_qpIn__29
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
qpIn__29
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
qpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_qpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "qpOut__4" c_qpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
qpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
qpOut__4 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_qpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "ramp" c_ramp
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>ramp function
>
>\\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \\\\\\\\
>\\\\end {cases} \\\\]
>
>Also called: slope function
-}
ramp
  :: SX -> IO SX
ramp x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_ramp errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rank" c_rank
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
{-|
>Obtain the structural rank of a sparsity-pattern.
-}
rank
  :: Sparsity -> IO Int
rank x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rank errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "rdaeIn__4" c_rdaeIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
rdaeIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
rdaeIn__4 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_rdaeIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rdaeIn__5" c_rdaeIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
rdaeIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
rdaeIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rdaeIn__6" c_rdaeIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
rdaeIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
rdaeIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rdaeIn__7" c_rdaeIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
rdaeIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
rdaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "rdaeIn__12" c_rdaeIn__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
rdaeIn__12
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
rdaeIn__12 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_rdaeIn__12 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rdaeIn__13" c_rdaeIn__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
rdaeIn__13
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
rdaeIn__13 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__13 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rdaeIn__14" c_rdaeIn__14
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
rdaeIn__14
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
rdaeIn__14 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "rdaeIn__15" c_rdaeIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
rdaeIn__15
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
rdaeIn__15 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "rdaeIn__20" c_rdaeIn__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
rdaeIn__20
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
rdaeIn__20 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_rdaeIn__20 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "rdaeIn__23" c_rdaeIn__23
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
rdaeIn__23
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
rdaeIn__23 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rdaeIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "rectangle" c_rectangle
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>rectangle function
>
>\\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) = 1/2 &
>|x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end {cases} \\\\]
>
>Also called: gate function, block function, band function, pulse function,
>window function
-}
rectangle
  :: SX -> IO SX
rectangle x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_rectangle errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "repmat__0" c_repmat__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
{-|
>Repeat matrix A n times vertically and m times horizontally.
-}
repmat__0
  :: MX -> Int -> Int -> IO MX
repmat__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_repmat__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "repmat__1" c_repmat__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
{-|
>Repeat matrix A n times vertically and m times horizontally.
-}
repmat__1
  :: SX -> Int -> Int -> IO SX
repmat__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_repmat__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "repmat__2" c_repmat__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
{-|
>Repeat matrix A n times vertically and m times horizontally.
-}
repmat__2
  :: DMatrix -> Int -> Int -> IO DMatrix
repmat__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_repmat__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "repmat__3" c_repmat__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
{-|
>Repeat matrix A n times vertically and m times horizontally.
-}
repmat__3
  :: IMatrix -> Int -> Int -> IO IMatrix
repmat__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_repmat__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "reshape__0" c_reshape__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
{-|
>Reshape the MX.
-}
reshape__0
  :: MX -> Sparsity -> IO MX
reshape__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_reshape__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "reshape__1" c_reshape__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
{-|
>Reshape the sparsity pattern keeping the relative location of the nonzeros.
-}
reshape__1
  :: Sparsity -> Int -> Int -> IO Sparsity
reshape__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_reshape__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "sdpIn__4" c_sdpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpIn__4 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_sdpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__5" c_sdpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__6" c_sdpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__7" c_sdpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__8" c_sdpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdpIn__13" c_sdpIn__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpIn__13
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
sdpIn__13 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_sdpIn__13 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__14" c_sdpIn__14
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpIn__14
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpIn__14 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__15" c_sdpIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpIn__15
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpIn__15 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__16" c_sdpIn__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpIn__16
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__17" c_sdpIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpIn__17
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdpIn__22" c_sdpIn__22
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdpIn__22
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
sdpIn__22 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_sdpIn__22 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "sdpIn__25" c_sdpIn__25
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdpIn__25
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpIn__26" c_sdpIn__26
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdpIn__26
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdpOut__4" c_sdpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpOut__4 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_sdpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpOut__5" c_sdpOut__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpOut__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpOut__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpOut__6" c_sdpOut__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpOut__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpOut__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpOut__7" c_sdpOut__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdpOut__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdpOut__12" c_sdpOut__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpOut__12
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
sdpOut__12 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_sdpOut__12 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpOut__13" c_sdpOut__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpOut__13
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpOut__13 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpOut__14" c_sdpOut__14
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpOut__14
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpOut__14 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdpOut__15" c_sdpOut__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdpOut__15
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdpOut__15 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdpOut__20" c_sdpOut__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdpOut__20
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
sdpOut__20 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_sdpOut__20 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "sdpOut__23" c_sdpOut__23
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdpOut__23
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


foreign import ccall unsafe "sdqpIn__4" c_sdqpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpIn__4 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_sdqpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__5" c_sdqpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__6" c_sdqpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__7" c_sdqpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__8" c_sdqpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__9" c_sdqpIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


foreign import ccall unsafe "sdqpIn__15" c_sdqpIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpIn__15
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpIn__15 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__16" c_sdqpIn__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpIn__16
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpIn__16 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__17" c_sdqpIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpIn__17
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__18" c_sdqpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpIn__18
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__19" c_sdqpIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdqpIn__24" c_sdqpIn__24
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdqpIn__24
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
sdqpIn__24 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_sdqpIn__24 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "sdqpIn__27" c_sdqpIn__27
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdqpIn__27
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdqpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__28" c_sdqpIn__28
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdqpIn__28
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdqpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpIn__29" c_sdqpIn__29
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdqpIn__29
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdqpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdqpOut__4" c_sdqpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpOut__4 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_sdqpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpOut__5" c_sdqpOut__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpOut__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpOut__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpOut__6" c_sdqpOut__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpOut__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpOut__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpOut__7" c_sdqpOut__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpOut__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdqpOut__12" c_sdqpOut__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpOut__12
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
sdqpOut__12 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_sdqpOut__12 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpOut__13" c_sdqpOut__13
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpOut__13
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpOut__13 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpOut__14" c_sdqpOut__14
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpOut__14
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpOut__14 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sdqpOut__15" c_sdqpOut__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
sdqpOut__15
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
sdqpOut__15 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdqpOut__20" c_sdqpOut__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdqpOut__20
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
sdqpOut__20 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_sdqpOut__20 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "sdqpOut__23" c_sdqpOut__23
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
sdqpOut__23
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
sdqpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sdqpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "sdqpStruct__4" c_sdqpStruct__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
sdqpStruct__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
sdqpStruct__4 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_sdqpStruct__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "simplify__0" c_simplify__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
{-|
>Simplify an expression.
-}
simplify__0
  :: MX -> IO ()
simplify__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_simplify__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "simplify__1" c_simplify__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
{-|
>Simplify an expression.
-}
simplify__1
  :: SX -> IO ()
simplify__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_simplify__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "socpIn__4" c_socpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__4 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_socpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__5" c_socpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__6" c_socpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__7" c_socpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__8" c_socpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__9" c_socpIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__10" c_socpIn__10
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpIn__10
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
socpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "socpIn__15" c_socpIn__15
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__15
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
socpIn__15 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_socpIn__15 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__16" c_socpIn__16
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__16
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
socpIn__16 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__17" c_socpIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__17
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
socpIn__17 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__18" c_socpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__18
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
socpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__19" c_socpIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
socpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__20" c_socpIn__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__20
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
socpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__21" c_socpIn__21
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
socpIn__21
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
socpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "socpIn__26" c_socpIn__26
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
socpIn__26
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
socpIn__26 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_socpIn__26 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "socpIn__29" c_socpIn__29
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
socpIn__29
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
socpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__30" c_socpIn__30
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
socpIn__30
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
socpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__31" c_socpIn__31
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
socpIn__31
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
socpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "socpIn__32" c_socpIn__32
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
socpIn__32
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
socpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_socpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "socpOut__4" c_socpOut__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
socpOut__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
socpOut__4 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_socpOut__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


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


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


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


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


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


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


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


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


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


foreign import ccall unsafe "solve__0" c_solve__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Solve a system of equations: A*x = b.
-}
solve__0
  :: MX -> MX -> IO MX
solve__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_solve__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "solve__1" c_solve__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
{-|
>Solve a system of equations: A*x = b.
-}
solve__1
  :: MX -> MX -> String -> IO MX
solve__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_solve__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "solve__2" c_solve__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Solve a system of equations: A*x = b The solve routine works similar to
>Matlab's backslash when A is square and nonsingular. The algorithm used is
>the following:
>
>A simple forward or backward substitution if A is upper or lower triangular
>
>If the linear system is at most 3-by-3, form the inverse via minor expansion
>and multiply
>
>Permute the variables and equations as to get a (structurally) nonzero
>diagonal, then perform a QR factorization without pivoting and solve the
>factorized system.
>
>Note 1: If there are entries of the linear system known to be zero, these
>will be removed. Elements that are very small, or will evaluate to be zero,
>can still cause numerical errors, due to the lack of pivoting (which is not
>possible since cannot compare the size of entries)
>
>Note 2: When permuting the linear system, a BLT (block lower triangular)
>transformation is formed. Only the permutation part of this is however used.
>An improvement would be to solve block-by-block if there are multiple BLT
>blocks.
-}
solve__2
  :: SX -> SX -> IO SX
solve__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_solve__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "solve__3" c_solve__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Solve a system of equations: A*x = b The solve routine works similar to
>Matlab's backslash when A is square and nonsingular. The algorithm used is
>the following:
>
>A simple forward or backward substitution if A is upper or lower triangular
>
>If the linear system is at most 3-by-3, form the inverse via minor expansion
>and multiply
>
>Permute the variables and equations as to get a (structurally) nonzero
>diagonal, then perform a QR factorization without pivoting and solve the
>factorized system.
>
>Note 1: If there are entries of the linear system known to be zero, these
>will be removed. Elements that are very small, or will evaluate to be zero,
>can still cause numerical errors, due to the lack of pivoting (which is not
>possible since cannot compare the size of entries)
>
>Note 2: When permuting the linear system, a BLT (block lower triangular)
>transformation is formed. Only the permutation part of this is however used.
>An improvement would be to solve block-by-block if there are multiple BLT
>blocks.
-}
solve__3
  :: DMatrix -> DMatrix -> IO DMatrix
solve__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_solve__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "solve__4" c_solve__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Solve a system of equations: A*x = b The solve routine works similar to
>Matlab's backslash when A is square and nonsingular. The algorithm used is
>the following:
>
>A simple forward or backward substitution if A is upper or lower triangular
>
>If the linear system is at most 3-by-3, form the inverse via minor expansion
>and multiply
>
>Permute the variables and equations as to get a (structurally) nonzero
>diagonal, then perform a QR factorization without pivoting and solve the
>factorized system.
>
>Note 1: If there are entries of the linear system known to be zero, these
>will be removed. Elements that are very small, or will evaluate to be zero,
>can still cause numerical errors, due to the lack of pivoting (which is not
>possible since cannot compare the size of entries)
>
>Note 2: When permuting the linear system, a BLT (block lower triangular)
>transformation is formed. Only the permutation part of this is however used.
>An improvement would be to solve block-by-block if there are multiple BLT
>blocks.
-}
solve__4
  :: IMatrix -> IMatrix -> IO IMatrix
solve__4 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_solve__4 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "solve__5" c_solve__5
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')
{-|
>Solve a system of equations: A*x = b.
-}
solve__5
  :: DMatrix -> DMatrix -> String -> IO DMatrix
solve__5 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_solve__5 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sparse__0" c_sparse__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Make a matrix sparse by removing numerical zeros.
-}
sparse__0
  :: SX -> IO SX
sparse__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sparse__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sparse__1" c_sparse__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX')
{-|
>Make a matrix sparse by removing numerical zeros.
-}
sparse__1
  :: SX -> Double -> IO SX
sparse__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sparse__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sparse__2" c_sparse__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Make a matrix sparse by removing numerical zeros.
-}
sparse__2
  :: DMatrix -> IO DMatrix
sparse__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sparse__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sparse__3" c_sparse__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix')
{-|
>Make a matrix sparse by removing numerical zeros.
-}
sparse__3
  :: DMatrix -> Double -> IO DMatrix
sparse__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sparse__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sparse__4" c_sparse__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Make a matrix sparse by removing numerical zeros.
-}
sparse__4
  :: IMatrix -> IO IMatrix
sparse__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sparse__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sparse__5" c_sparse__5
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix')
{-|
>Make a matrix sparse by removing numerical zeros.
-}
sparse__5
  :: IMatrix -> Double -> IO IMatrix
sparse__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sparse__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sprank__0" c_sprank__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
{-|
>Obtain the structural rank of a sparsity-pattern.
-}
sprank__0
  :: SX -> IO Int
sprank__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sprank__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sprank__1" c_sprank__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
{-|
>Obtain the structural rank of a sparsity-pattern.
-}
sprank__1
  :: DMatrix -> IO Int
sprank__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sprank__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sprank__2" c_sprank__2
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
{-|
>Obtain the structural rank of a sparsity-pattern.
-}
sprank__2
  :: IMatrix -> IO Int
sprank__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sprank__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "spy" c_spy
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Get the sparsity pattern of a matrix.
-}
spy
  :: SX -> IO SX
spy x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_spy errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "stabilizedQpIn__4" c_stabilizedQpIn__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__4
  :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__4 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_stabilizedQpIn__4 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__5" c_stabilizedQpIn__5
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__5
  :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__5 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__6" c_stabilizedQpIn__6
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__6
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__6 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__7" c_stabilizedQpIn__7
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__7
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__8" c_stabilizedQpIn__8
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__8
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__9" c_stabilizedQpIn__9
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__9
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__10" c_stabilizedQpIn__10
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__10
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__11" c_stabilizedQpIn__11
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__11
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__12" c_stabilizedQpIn__12
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
stabilizedQpIn__12
  :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
stabilizedQpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "stabilizedQpIn__17" c_stabilizedQpIn__17
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__17
  :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__17 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_stabilizedQpIn__17 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__18" c_stabilizedQpIn__18
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__18
  :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__18 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__19" c_stabilizedQpIn__19
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__19
  :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__19 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__20" c_stabilizedQpIn__20
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__20
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__21" c_stabilizedQpIn__21
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__21
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__22" c_stabilizedQpIn__22
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__22
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__23" c_stabilizedQpIn__23
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__23
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__24" c_stabilizedQpIn__24
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__24
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__25" c_stabilizedQpIn__25
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
stabilizedQpIn__25
  :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
stabilizedQpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


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


foreign import ccall unsafe "stabilizedQpIn__30" c_stabilizedQpIn__30
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__30
  :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__30 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_stabilizedQpIn__30 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


foreign import ccall unsafe "stabilizedQpIn__33" c_stabilizedQpIn__33
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__33
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__34" c_stabilizedQpIn__34
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__34
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__35" c_stabilizedQpIn__35
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__35
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__36" c_stabilizedQpIn__36
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__36
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__37" c_stabilizedQpIn__37
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__37
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "stabilizedQpIn__38" c_stabilizedQpIn__38
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
stabilizedQpIn__38
  :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
stabilizedQpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  withMarshal x8 $ \x8' ->
  withMarshal x9 $ \x9' ->
  withMarshal x10 $ \x10' ->
  withMarshal x11 $ \x11' ->
  withMarshal x12 $ \x12' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_stabilizedQpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substitute__0" c_substitute__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>Substitute variable var with expression expr in multiple expressions.
-}
substitute__0
  :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
substitute__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substitute__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substitute__1" c_substitute__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Substitute variable v with expression vdef in an expression ex.
-}
substitute__1
  :: MX -> MX -> MX -> IO MX
substitute__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substitute__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substitute__2" c_substitute__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
{-|
>Substitute variable var with expression expr in multiple expressions.
-}
substitute__2
  :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX)
substitute__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substitute__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substitute__3" c_substitute__3
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Substitute variable v with expression vdef in an expression ex.
-}
substitute__3
  :: SX -> SX -> SX -> IO SX
substitute__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substitute__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substituteInPlace__0" c_substituteInPlace__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
{-|
>Substitute variable var out of or into an expression expr, with an arbitrary
>number of other expressions piggyback (vector version)
-}
substituteInPlace__0
  :: Vector SX -> Vector SX -> Vector SX -> IO ()
substituteInPlace__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substituteInPlace__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substituteInPlace__1" c_substituteInPlace__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
{-|
>Substitute variable var out of or into an expression expr, with an arbitrary
>number of other expressions piggyback (vector version)
-}
substituteInPlace__1
  :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO ()
substituteInPlace__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substituteInPlace__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substituteInPlace__2" c_substituteInPlace__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> IO ()
{-|
>Substitute variable var out of or into an expression expr, with an arbitrary
>number of other expressions piggyback.
-}
substituteInPlace__2
  :: SX -> SX -> Vector SX -> IO ()
substituteInPlace__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substituteInPlace__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substituteInPlace__3" c_substituteInPlace__3
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
{-|
>Substitute variable var out of or into an expression expr, with an arbitrary
>number of other expressions piggyback.
-}
substituteInPlace__3
  :: SX -> SX -> Vector SX -> Bool -> IO ()
substituteInPlace__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substituteInPlace__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substituteInPlace__4" c_substituteInPlace__4
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO ()
{-|
>Substitute variable var out of or into an expression expr.
-}
substituteInPlace__4
  :: SX -> SX -> IO ()
substituteInPlace__4 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substituteInPlace__4 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "substituteInPlace__5" c_substituteInPlace__5
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO ()
{-|
>Substitute variable var out of or into an expression expr.
-}
substituteInPlace__5
  :: SX -> SX -> Bool -> IO ()
substituteInPlace__5 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_substituteInPlace__5 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumAll__0" c_sumAll__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Return summation of all elements.
-}
sumAll__0
  :: MX -> IO MX
sumAll__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumAll__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumAll__1" c_sumAll__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Return summation of all elements.
-}
sumAll__1
  :: SX -> IO SX
sumAll__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumAll__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumAll__2" c_sumAll__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Return summation of all elements.
-}
sumAll__2
  :: DMatrix -> IO DMatrix
sumAll__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumAll__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumAll__3" c_sumAll__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Return summation of all elements.
-}
sumAll__3
  :: IMatrix -> IO IMatrix
sumAll__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumAll__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumCols__0" c_sumCols__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Return a col-wise summation of elements.
-}
sumCols__0
  :: MX -> IO MX
sumCols__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumCols__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumCols__1" c_sumCols__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Return a col-wise summation of elements.
-}
sumCols__1
  :: SX -> IO SX
sumCols__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumCols__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumCols__2" c_sumCols__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Return a col-wise summation of elements.
-}
sumCols__2
  :: DMatrix -> IO DMatrix
sumCols__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumCols__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumCols__3" c_sumCols__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Return a col-wise summation of elements.
-}
sumCols__3
  :: IMatrix -> IO IMatrix
sumCols__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumCols__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumRows__0" c_sumRows__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Return a row-wise summation of elements.
-}
sumRows__0
  :: MX -> IO MX
sumRows__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumRows__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumRows__1" c_sumRows__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Return a row-wise summation of elements.
-}
sumRows__1
  :: SX -> IO SX
sumRows__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumRows__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumRows__2" c_sumRows__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Return a row-wise summation of elements.
-}
sumRows__2
  :: DMatrix -> IO DMatrix
sumRows__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumRows__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "sumRows__3" c_sumRows__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Return a row-wise summation of elements.
-}
sumRows__3
  :: IMatrix -> IO IMatrix
sumRows__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_sumRows__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tangent__0" c_tangent__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>split vertically, retaining groups of cols
>
>Parameters:
>-----------
>
>output_offset:  List of all start cols for each group the last col group
>will run to the end.
>
>horzcat(horzsplit(x, ...)) = x
-}
tangent__0
  :: MX -> MX -> IO MX
tangent__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tangent__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tangent__1" c_tangent__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Integrate f from a to b using Gaussian quadrature with n points.
-}
tangent__1
  :: SX -> SX -> IO SX
tangent__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tangent__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "taylor__0" c_taylor__0
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>univariate Taylor series expansion
>
>Calculate the Taylor expansion of expression 'ex' up to order 'order' with
>respect to variable 'x' around the point 'a'
>
>$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
>{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
>
>Example usage:>>   x
-}
taylor__0
  :: SX -> SX -> IO SX
taylor__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_taylor__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "taylor__1" c_taylor__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>univariate Taylor series expansion
>
>Calculate the Taylor expansion of expression 'ex' up to order 'order' with
>respect to variable 'x' around the point 'a'
>
>$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
>{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
>
>Example usage:>>   x
-}
taylor__1
  :: SX -> SX -> SX -> IO SX
taylor__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_taylor__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "taylor__2" c_taylor__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
{-|
>univariate Taylor series expansion
>
>Calculate the Taylor expansion of expression 'ex' up to order 'order' with
>respect to variable 'x' around the point 'a'
>
>$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
>{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
>
>Example usage:>>   x
-}
taylor__2
  :: SX -> SX -> SX -> Int -> IO SX
taylor__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_taylor__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "trace__0" c_trace__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Matrix trace.
-}
trace__0
  :: MX -> IO MX
trace__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_trace__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


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


foreign import ccall unsafe "transpose__0" c_transpose__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Transpose an expression.
-}
transpose__0
  :: MX -> IO MX
transpose__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_transpose__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "transpose__1" c_transpose__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
{-|
>Transpose the pattern.
-}
transpose__1
  :: Sparsity -> IO Sparsity
transpose__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_transpose__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "transpose__2" c_transpose__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Transpose of a matrix.
-}
transpose__2
  :: SX -> IO SX
transpose__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_transpose__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "transpose__3" c_transpose__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Transpose of a matrix.
-}
transpose__3
  :: DMatrix -> IO DMatrix
transpose__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_transpose__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "transpose__4" c_transpose__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Transpose of a matrix.
-}
transpose__4
  :: IMatrix -> IO IMatrix
transpose__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_transpose__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triangle" c_triangle
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>triangle function
>
>\\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \\\\Lambda(x)
>= 1-|x| & |x| < 1 \\\\end {cases} \\\\]
-}
triangle
  :: SX -> IO SX
triangle x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triangle errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril__0" c_tril__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
{-|
>Get lower triangular part.
-}
tril__0
  :: Sparsity -> IO Sparsity
tril__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril__1" c_tril__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
{-|
>Get lower triangular part.
-}
tril__1
  :: Sparsity -> Bool -> IO Sparsity
tril__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril__2" c_tril__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Get the lower triangular part of a matrix.
-}
tril__2
  :: MX -> IO MX
tril__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril__3" c_tril__3
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Get the lower triangular part of a matrix.
-}
tril__3
  :: SX -> IO SX
tril__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril__4" c_tril__4
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Get the lower triangular part of a matrix.
-}
tril__4
  :: DMatrix -> IO DMatrix
tril__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril__5" c_tril__5
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Get the lower triangular part of a matrix.
-}
tril__5
  :: IMatrix -> IO IMatrix
tril__5 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril__5 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril2symm__0" c_tril2symm__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Convert a lower triangular matrix to a symmetric one.
-}
tril2symm__0
  :: MX -> IO MX
tril2symm__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril2symm__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril2symm__1" c_tril2symm__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Convert a lower triangular matrix to a symmetric one.
-}
tril2symm__1
  :: SX -> IO SX
tril2symm__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril2symm__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril2symm__2" c_tril2symm__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Convert a lower triangular matrix to a symmetric one.
-}
tril2symm__2
  :: DMatrix -> IO DMatrix
tril2symm__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril2symm__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "tril2symm__3" c_tril2symm__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Convert a lower triangular matrix to a symmetric one.
-}
tril2symm__3
  :: IMatrix -> IO IMatrix
tril2symm__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_tril2symm__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu__0" c_triu__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
{-|
>Get upper triangular part.
-}
triu__0
  :: Sparsity -> IO Sparsity
triu__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu__1" c_triu__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
{-|
>Get upper triangular part.
-}
triu__1
  :: Sparsity -> Bool -> IO Sparsity
triu__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu__2" c_triu__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Get the upper triangular part of a matrix.
-}
triu__2
  :: MX -> IO MX
triu__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu__3" c_triu__3
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Get the upper triangular part of a matrix.
-}
triu__3
  :: SX -> IO SX
triu__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu__4" c_triu__4
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Get the upper triangular part of a matrix.
-}
triu__4
  :: DMatrix -> IO DMatrix
triu__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu__5" c_triu__5
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Get the upper triangular part of a matrix.
-}
triu__5
  :: IMatrix -> IO IMatrix
triu__5 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu__5 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu2symm__0" c_triu2symm__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Convert a upper triangular matrix to a symmetric one.
-}
triu2symm__0
  :: MX -> IO MX
triu2symm__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu2symm__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu2symm__1" c_triu2symm__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Convert a upper triangular matrix to a symmetric one.
-}
triu2symm__1
  :: SX -> IO SX
triu2symm__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu2symm__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu2symm__2" c_triu2symm__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Convert a upper triangular matrix to a symmetric one.
-}
triu2symm__2
  :: DMatrix -> IO DMatrix
triu2symm__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu2symm__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "triu2symm__3" c_triu2symm__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Convert a upper triangular matrix to a symmetric one.
-}
triu2symm__3
  :: IMatrix -> IO IMatrix
triu2symm__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_triu2symm__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "unite__0" c_unite__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
{-|
>Unite two matrices no overlapping sparsity.
-}
unite__0
  :: MX -> MX -> IO MX
unite__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_unite__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "unite__1" c_unite__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
{-|
>Unite two matrices no overlapping sparsity.
-}
unite__1
  :: SX -> SX -> IO SX
unite__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_unite__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "unite__2" c_unite__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Unite two matrices no overlapping sparsity.
-}
unite__2
  :: DMatrix -> DMatrix -> IO DMatrix
unite__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_unite__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "unite__3" c_unite__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Unite two matrices no overlapping sparsity.
-}
unite__3
  :: IMatrix -> IMatrix -> IO IMatrix
unite__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_unite__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vec__0" c_vec__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Returns a vectorized version of the MX Same as reshape(x, x.numel(), 1)
>
>a c b d
>
>turns into
>
>a b c d
-}
vec__0
  :: MX -> IO MX
vec__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vec__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vec__1" c_vec__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
{-|
>Vectorize the pattern.
-}
vec__1
  :: Sparsity -> IO Sparsity
vec__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vec__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vec__2" c_vec__2
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>make a vector Reshapes/vectorizes the Matrix<DataType> such that the shape
>becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
>reshape(expr, expr.numel(), 1)
>
>a c b d  turns into
>
>a b c d
-}
vec__2
  :: SX -> IO SX
vec__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vec__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vec__3" c_vec__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>make a vector Reshapes/vectorizes the Matrix<DataType> such that the shape
>becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
>reshape(expr, expr.numel(), 1)
>
>a c b d  turns into
>
>a b c d
-}
vec__3
  :: DMatrix -> IO DMatrix
vec__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vec__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vec__4" c_vec__4
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>make a vector Reshapes/vectorizes the Matrix<DataType> such that the shape
>becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
>reshape(expr, expr.numel(), 1)
>
>a c b d  turns into
>
>a b c d
-}
vec__4
  :: IMatrix -> IO IMatrix
vec__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vec__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZ__0" c_vecNZ__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
{-|
>Returns a vectorized version of the MX, preserving only nonzeros.
-}
vecNZ__0
  :: MX -> IO MX
vecNZ__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZ__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZ__1" c_vecNZ__1
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
{-|
>Returns a flattened version of the Matrix, preserving only nonzeros.
-}
vecNZ__1
  :: SX -> IO SX
vecNZ__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZ__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZ__2" c_vecNZ__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
{-|
>Returns a flattened version of the Matrix, preserving only nonzeros.
-}
vecNZ__2
  :: DMatrix -> IO DMatrix
vecNZ__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZ__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZ__3" c_vecNZ__3
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
{-|
>Returns a flattened version of the Matrix, preserving only nonzeros.
-}
vecNZ__3
  :: IMatrix -> IO IMatrix
vecNZ__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZ__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZcat__0" c_vecNZcat__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>concatenate vertically while vecing all arguments with vecNZ
-}
vecNZcat__0
  :: Vector MX -> IO MX
vecNZcat__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZcat__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZcat__1" c_vecNZcat__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
{-|
>concatenate vertically while vectorizing all arguments with vecNZ
-}
vecNZcat__1
  :: Vector SX -> IO SX
vecNZcat__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZcat__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZcat__2" c_vecNZcat__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
{-|
>concatenate vertically while vectorizing all arguments with vecNZ
-}
vecNZcat__2
  :: Vector DMatrix -> IO DMatrix
vecNZcat__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZcat__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vecNZcat__3" c_vecNZcat__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
{-|
>concatenate vertically while vectorizing all arguments with vecNZ
-}
vecNZcat__3
  :: Vector IMatrix -> IO IMatrix
vecNZcat__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vecNZcat__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "veccat__0" c_veccat__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>Concatenate vertically while vectorizing all arguments.
-}
veccat__0
  :: Vector MX -> IO MX
veccat__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_veccat__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "veccat__1" c_veccat__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
{-|
>concatenate vertically while vectorizing all arguments with vec
-}
veccat__1
  :: Vector SX -> IO SX
veccat__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_veccat__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "veccat__2" c_veccat__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
{-|
>concatenate vertically while vectorizing all arguments with vec
-}
veccat__2
  :: Vector DMatrix -> IO DMatrix
veccat__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_veccat__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "veccat__3" c_veccat__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
{-|
>concatenate vertically while vectorizing all arguments with vec
-}
veccat__3
  :: Vector IMatrix -> IO IMatrix
veccat__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_veccat__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertcat__0" c_vertcat__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
{-|
>concatenate horizontally
>
>vertcat(vertsplit(x, ...)) = x
-}
vertcat__0
  :: Vector MX -> IO MX
vertcat__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertcat__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertcat__1" c_vertcat__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
{-|
>Concatenate a list of sparsities vertically Alternative terminology:
>vertical stack, vstack, vertical append, [a;b].
-}
vertcat__1
  :: Vector Sparsity -> IO Sparsity
vertcat__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertcat__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertcat__2" c_vertcat__2
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
{-|
>Concatenate a list of matrices horizontally Alternative terminology:
>horizontal stack, hstack, horizontal append, [a b].
>
>vertcat(vertsplit(x, ...)) = x
-}
vertcat__2
  :: Vector SX -> IO SX
vertcat__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertcat__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertcat__3" c_vertcat__3
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
{-|
>Concatenate a list of matrices horizontally Alternative terminology:
>horizontal stack, hstack, horizontal append, [a b].
>
>vertcat(vertsplit(x, ...)) = x
-}
vertcat__3
  :: Vector DMatrix -> IO DMatrix
vertcat__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertcat__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertcat__4" c_vertcat__4
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
{-|
>Concatenate a list of matrices horizontally Alternative terminology:
>horizontal stack, hstack, horizontal append, [a b].
>
>vertcat(vertsplit(x, ...)) = x
-}
vertcat__4
  :: Vector IMatrix -> IO IMatrix
vertcat__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertcat__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__0" c_vertsplit__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__0
  :: MX -> IO (Vector MX)
vertsplit__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__1" c_vertsplit__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__1
  :: MX -> Int -> IO (Vector MX)
vertsplit__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__2" c_vertsplit__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
{-|
>split horizontally, retaining groups of rows
>
>Parameters:
>-----------
>
>output_offset:  List of all start rows for each group the last row group
>will run to the end.
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__2
  :: MX -> Vector Int -> IO (Vector MX)
vertsplit__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__3" c_vertsplit__3
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
{-|
>Split up a sparsity pattern vertically.
-}
vertsplit__3
  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
vertsplit__3 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__3 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__4" c_vertsplit__4
  :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__4
  :: SX -> IO (Vector SX)
vertsplit__4 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__4 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__5" c_vertsplit__5
  :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__5
  :: SX -> Int -> IO (Vector SX)
vertsplit__5 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__5 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__6" c_vertsplit__6
  :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
{-|
>split horizontally, retaining groups of rows
>
>Parameters:
>-----------
>
>output_offset:  List of all start rows for each group the last row group
>will run to the end.
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__6
  :: SX -> Vector Int -> IO (Vector SX)
vertsplit__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__7" c_vertsplit__7
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__7
  :: DMatrix -> IO (Vector DMatrix)
vertsplit__7 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__7 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__8" c_vertsplit__8
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__8
  :: DMatrix -> Int -> IO (Vector DMatrix)
vertsplit__8 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__8 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__9" c_vertsplit__9
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
{-|
>split horizontally, retaining groups of rows
>
>Parameters:
>-----------
>
>output_offset:  List of all start rows for each group the last row group
>will run to the end.
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__9
  :: DMatrix -> Vector Int -> IO (Vector DMatrix)
vertsplit__9 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__9 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__10" c_vertsplit__10
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__10
  :: IMatrix -> IO (Vector IMatrix)
vertsplit__10 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__10 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__11" c_vertsplit__11
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
{-|
>split horizontally, retaining fixed-sized groups of rows
>
>Parameters:
>-----------
>
>incr:  Size of each group of rows
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__11
  :: IMatrix -> Int -> IO (Vector IMatrix)
vertsplit__11 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__11 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


foreign import ccall unsafe "vertsplit__12" c_vertsplit__12
  :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
{-|
>split horizontally, retaining groups of rows
>
>Parameters:
>-----------
>
>output_offset:  List of all start rows for each group the last row group
>will run to the end.
>
>vertcat(vertsplit(x, ...)) = x
-}
vertsplit__12
  :: IMatrix -> Vector Int -> IO (Vector IMatrix)
vertsplit__12 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_vertsplit__12 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)