casadi-bindings-core-1.9.0.1: cbits/autogen/core_functions.cpp

#include "casadi/core/casadi_calculus.hpp"
#include "casadi/core/casadi_exception.hpp"
#include "casadi/core/casadi_meta.hpp"
#include "casadi/core/casadi_options.hpp"
#include "casadi/core/casadi_types.hpp"
#include "casadi/core/function/control_simulator.hpp"
#include "casadi/core/function/custom_function.hpp"
#include "casadi/core/function/external_function.hpp"
#include "casadi/core/function/function.hpp"
#include "casadi/core/function/homotopy_nlp_solver.hpp"
#include "casadi/core/function/implicit_function.hpp"
#include "casadi/core/function/integrator.hpp"
#include "casadi/core/function/io_interface.hpp"
#include "casadi/core/function/linear_solver.hpp"
#include "casadi/core/function/lp_solver.hpp"
#include "casadi/core/function/mx_function.hpp"
#include "casadi/core/function/nlp_solver.hpp"
#include "casadi/core/function/nullspace.hpp"
#include "casadi/core/function/ocp_solver.hpp"
#include "casadi/core/function/parallelizer.hpp"
#include "casadi/core/function/qcqp_solver.hpp"
#include "casadi/core/function/qp_solver.hpp"
#include "casadi/core/function/sdp_solver.hpp"
#include "casadi/core/function/sdqp_solver.hpp"
#include "casadi/core/function/simulator.hpp"
#include "casadi/core/function/socp_solver.hpp"
#include "casadi/core/function/stabilized_qp_solver.hpp"
#include "casadi/core/function/sx_function.hpp"
#include "casadi/core/function/symbolic_qr.hpp"
#include "casadi/core/functor.hpp"
#include "casadi/core/generic_type.hpp"
#include "casadi/core/matrix/generic_expression.hpp"
#include "casadi/core/matrix/generic_matrix.hpp"
#include "casadi/core/matrix/matrix.hpp"
#include "casadi/core/matrix/matrix_tools.hpp"
#include "casadi/core/matrix/slice.hpp"
#include "casadi/core/matrix/sparsity.hpp"
#include "casadi/core/matrix/sparsity_tools.hpp"
#include "casadi/core/mx/mx.hpp"
#include "casadi/core/mx/mx_tools.hpp"
#include "casadi/core/options_functionality.hpp"
#include "casadi/core/printable_object.hpp"
#include "casadi/core/shared_object.hpp"
#include "casadi/core/std_vector_tools.hpp"
#include "casadi/core/sx/sx_element.hpp"
#include "casadi/core/sx/sx_tools.hpp"
#include "casadi/core/weak_ref.hpp"
#include <cmath>
#include <sstream>
#include <stdexcept>
#include "../marshal.hpp"

// ================== function "casadi::addMultiple" ===============
// cppName: "casadi::addMultiple"
// cWrapperName: "addMultiple__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void addMultiple__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// call: "casadi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void addMultiple__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2);
void addMultiple__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        std::vector< casadi::SXElement > x1_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);

    casadi::addMultiple(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::addMultiple" ===============
// cppName: "casadi::addMultiple"
// cWrapperName: "addMultiple__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),CBool]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void addMultiple__1(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, int x3)"
// call: "casadi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void addMultiple__1(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, int x3);
void addMultiple__1(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, int x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        std::vector< casadi::SXElement > x1_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

    casadi::addMultiple(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::addMultiple" ===============
// cppName: "casadi::addMultiple"
// cWrapperName: "addMultiple__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CDouble)),Ref (StdVec CDouble)]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void addMultiple__2(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2)"
// call: "casadi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void addMultiple__2(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2);
void addMultiple__2(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
        std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

    casadi::addMultiple(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::addMultiple" ===============
// cppName: "casadi::addMultiple"
// cWrapperName: "addMultiple__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CDouble)),Ref (StdVec CDouble),CBool]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void addMultiple__3(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2, int x3)"
// call: "casadi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void addMultiple__3(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2, int x3);
void addMultiple__3(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2, int x3){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
        std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

    casadi::addMultiple(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::addMultiple" ===============
// cppName: "casadi::addMultiple"
// cWrapperName: "addMultiple__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void addMultiple__4(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void addMultiple__4(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
void addMultiple__4(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    casadi::addMultiple(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::addMultiple" ===============
// cppName: "casadi::addMultiple"
// cWrapperName: "addMultiple__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (StdVec CInt),CBool]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void addMultiple__5(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2, int x3)"
// call: "casadi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void addMultiple__5(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2, int x3);
void addMultiple__5(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2, int x3){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

    casadi::addMultiple(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::adj" ===============
// cppName: "casadi::adj"
// cWrapperName: "adj__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* adj__0(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::adj(x0_)"
extern "C"
    casadi::SX* adj__0(std::string ** err_msg, casadi::SX* x0);
casadi::SX* adj__0(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::adj(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::adj" ===============
// cppName: "casadi::adj"
// cWrapperName: "adj__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* adj__1(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::adj(x0_)"
extern "C"
    casadi::DMatrix* adj__1(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* adj__1(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::adj(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::adj" ===============
// cppName: "casadi::adj"
// cWrapperName: "adj__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* adj__2(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::adj(x0_)"
extern "C"
    casadi::IMatrix* adj__2(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* adj__2(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::adj(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blkdiag" ===============
// cppName: "casadi::blkdiag"
// cWrapperName: "blkdiag__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* blkdiag__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::blkdiag(x0_)"
extern "C"
    casadi::MX* blkdiag__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* blkdiag__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::blkdiag(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blkdiag" ===============
// cppName: "casadi::blkdiag"
// cWrapperName: "blkdiag__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* blkdiag__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::blkdiag(x0_)"
extern "C"
    casadi::Sparsity* blkdiag__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
casadi::Sparsity* blkdiag__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        casadi::Sparsity ret = casadi::blkdiag(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blkdiag" ===============
// cppName: "casadi::blkdiag"
// cWrapperName: "blkdiag__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* blkdiag__2(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::blkdiag(x0_)"
extern "C"
    casadi::SX* blkdiag__2(std::string ** err_msg, std::vector< casadi::SX* >* x0);
casadi::SX* blkdiag__2(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SX ret = casadi::blkdiag(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blkdiag" ===============
// cppName: "casadi::blkdiag"
// cWrapperName: "blkdiag__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* blkdiag__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// call: "casadi::blkdiag(x0_)"
extern "C"
    casadi::DMatrix* blkdiag__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0);
casadi::DMatrix* blkdiag__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::blkdiag(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blkdiag" ===============
// cppName: "casadi::blkdiag"
// cWrapperName: "blkdiag__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* blkdiag__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// call: "casadi::blkdiag(x0_)"
extern "C"
    casadi::IMatrix* blkdiag__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0);
casadi::IMatrix* blkdiag__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0){
    try {
        std::vector< casadi::IMatrix > x0_ = Marshaling<std::vector< casadi::IMatrix >,std::vector< casadi::IMatrix* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::blkdiag(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blockcat" ===============
// cppName: "casadi::blockcat"
// cWrapperName: "blockcat__0"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< casadi::MX* >* >* x0)"
// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* blockcat__0(std::string ** err_msg, std::vector< std::vector< casadi::MX* >* >* x0)"
// call: "casadi::blockcat(x0_)"
extern "C"
    casadi::MX* blockcat__0(std::string ** err_msg, std::vector< std::vector< casadi::MX* >* >* x0);
casadi::MX* blockcat__0(std::string ** err_msg, std::vector< std::vector< casadi::MX* >* >* x0){
    try {
        std::vector< std::vector< casadi::MX > > x0_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x0);

        casadi::MX ret = casadi::blockcat(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blockcat" ===============
// cppName: "casadi::blockcat"
// cWrapperName: "blockcat__1"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< casadi::SX* >* >* x0)"
// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* blockcat__1(std::string ** err_msg, std::vector< std::vector< casadi::SX* >* >* x0)"
// call: "casadi::blockcat(x0_)"
extern "C"
    casadi::SX* blockcat__1(std::string ** err_msg, std::vector< std::vector< casadi::SX* >* >* x0);
casadi::SX* blockcat__1(std::string ** err_msg, std::vector< std::vector< casadi::SX* >* >* x0){
    try {
        std::vector< std::vector< casadi::SX > > x0_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x0);

        casadi::SX ret = casadi::blockcat(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blockcat" ===============
// cppName: "casadi::blockcat"
// cWrapperName: "blockcat__2"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< casadi::DMatrix* >* >* x0)"
// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* blockcat__2(std::string ** err_msg, std::vector< std::vector< casadi::DMatrix* >* >* x0)"
// call: "casadi::blockcat(x0_)"
extern "C"
    casadi::DMatrix* blockcat__2(std::string ** err_msg, std::vector< std::vector< casadi::DMatrix* >* >* x0);
casadi::DMatrix* blockcat__2(std::string ** err_msg, std::vector< std::vector< casadi::DMatrix* >* >* x0){
    try {
        std::vector< std::vector< casadi::DMatrix > > x0_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::blockcat(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blockcat" ===============
// cppName: "casadi::blockcat"
// cWrapperName: "blockcat__3"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< casadi::IMatrix* >* >* x0)"
// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* blockcat__3(std::string ** err_msg, std::vector< std::vector< casadi::IMatrix* >* >* x0)"
// call: "casadi::blockcat(x0_)"
extern "C"
    casadi::IMatrix* blockcat__3(std::string ** err_msg, std::vector< std::vector< casadi::IMatrix* >* >* x0);
casadi::IMatrix* blockcat__3(std::string ** err_msg, std::vector< std::vector< casadi::IMatrix* >* >* x0){
    try {
        std::vector< std::vector< casadi::IMatrix > > x0_ = Marshaling<std::vector< std::vector< casadi::IMatrix > >,std::vector< std::vector< casadi::IMatrix* >* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::blockcat(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* blocksplit__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< casadi::MX* >* >* blocksplit__0(std::string ** err_msg, casadi::MX* x0);
std::vector< std::vector< casadi::MX* >* >* blocksplit__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        std::vector< std::vector< casadi::MX > > ret = casadi::blocksplit(x0_);
        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* blocksplit__1(std::string ** err_msg, casadi::MX* x0, int x1)"
// call: "casadi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< casadi::MX* >* >* blocksplit__1(std::string ** err_msg, casadi::MX* x0, int x1);
std::vector< std::vector< casadi::MX* >* >* blocksplit__1(std::string ** err_msg, casadi::MX* x0, int x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< std::vector< casadi::MX > > ret = casadi::blocksplit(x0_, x1_);
        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* blocksplit__2(std::string ** err_msg, casadi::MX* x0, int x1, int x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::MX* >* >* blocksplit__2(std::string ** err_msg, casadi::MX* x0, int x1, int x2);
std::vector< std::vector< casadi::MX* >* >* blocksplit__2(std::string ** err_msg, casadi::MX* x0, int x1, int x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< std::vector< casadi::MX > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* blocksplit__3(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::MX* >* >* blocksplit__3(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< casadi::MX* >* >* blocksplit__3(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

        std::vector< std::vector< casadi::MX > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::MX* >* >*, std::vector< std::vector< casadi::MX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
// proto: "std::vector< std::vector< casadi::SX* >* >* blocksplit__4(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< casadi::SX* >* >* blocksplit__4(std::string ** err_msg, casadi::SX* x0);
std::vector< std::vector< casadi::SX* >* >* blocksplit__4(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        std::vector< std::vector< casadi::SX > > ret = casadi::blocksplit(x0_);
        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
// proto: "std::vector< std::vector< casadi::SX* >* >* blocksplit__5(std::string ** err_msg, casadi::SX* x0, int x1)"
// call: "casadi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< casadi::SX* >* >* blocksplit__5(std::string ** err_msg, casadi::SX* x0, int x1);
std::vector< std::vector< casadi::SX* >* >* blocksplit__5(std::string ** err_msg, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< std::vector< casadi::SX > > ret = casadi::blocksplit(x0_, x1_);
        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__6"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
// proto: "std::vector< std::vector< casadi::SX* >* >* blocksplit__6(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::SX* >* >* blocksplit__6(std::string ** err_msg, casadi::SX* x0, int x1, int x2);
std::vector< std::vector< casadi::SX* >* >* blocksplit__6(std::string ** err_msg, casadi::SX* x0, int x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< std::vector< casadi::SX > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__7"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
// proto: "std::vector< std::vector< casadi::SX* >* >* blocksplit__7(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::SX* >* >* blocksplit__7(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< casadi::SX* >* >* blocksplit__7(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

        std::vector< std::vector< casadi::SX > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::SX* >* >*, std::vector< std::vector< casadi::SX > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__8"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__8(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__8(std::string ** err_msg, casadi::DMatrix* x0);
std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__8(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        std::vector< std::vector< casadi::DMatrix > > ret = casadi::blocksplit(x0_);
        return WrapReturn< std::vector< std::vector< casadi::DMatrix* >* >*, std::vector< std::vector< casadi::DMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__9"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__9(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// call: "casadi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__9(std::string ** err_msg, casadi::DMatrix* x0, int x1);
std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__9(std::string ** err_msg, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< std::vector< casadi::DMatrix > > ret = casadi::blocksplit(x0_, x1_);
        return WrapReturn< std::vector< std::vector< casadi::DMatrix* >* >*, std::vector< std::vector< casadi::DMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__10"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__10(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__10(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2);
std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__10(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< std::vector< casadi::DMatrix > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::DMatrix* >* >*, std::vector< std::vector< casadi::DMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__11"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__11(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__11(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< casadi::DMatrix* >* >* blocksplit__11(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

        std::vector< std::vector< casadi::DMatrix > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::DMatrix* >* >*, std::vector< std::vector< casadi::DMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__12"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__12(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__12(std::string ** err_msg, casadi::IMatrix* x0);
std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__12(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        std::vector< std::vector< casadi::IMatrix > > ret = casadi::blocksplit(x0_);
        return WrapReturn< std::vector< std::vector< casadi::IMatrix* >* >*, std::vector< std::vector< casadi::IMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__13"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__13(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// call: "casadi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__13(std::string ** err_msg, casadi::IMatrix* x0, int x1);
std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__13(std::string ** err_msg, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< std::vector< casadi::IMatrix > > ret = casadi::blocksplit(x0_, x1_);
        return WrapReturn< std::vector< std::vector< casadi::IMatrix* >* >*, std::vector< std::vector< casadi::IMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__14"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__14(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__14(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2);
std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__14(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< std::vector< casadi::IMatrix > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::IMatrix* >* >*, std::vector< std::vector< casadi::IMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::blocksplit" ===============
// cppName: "casadi::blocksplit"
// cWrapperName: "blocksplit__15"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
// retType: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__15(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__15(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< casadi::IMatrix* >* >* blocksplit__15(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

        std::vector< std::vector< casadi::IMatrix > > ret = casadi::blocksplit(x0_, x1_, x2_);
        return WrapReturn< std::vector< std::vector< casadi::IMatrix* >* >*, std::vector< std::vector< casadi::IMatrix > > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cofactor" ===============
// cppName: "casadi::cofactor"
// cWrapperName: "cofactor__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* cofactor__0(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// call: "casadi::cofactor(x0_, x1_, x2_)"
extern "C"
    casadi::SXElement* cofactor__0(std::string ** err_msg, casadi::SX* x0, int x1, int x2);
casadi::SXElement* cofactor__0(std::string ** err_msg, casadi::SX* x0, int x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SXElement ret = casadi::cofactor(x0_, x1_, x2_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cofactor" ===============
// cppName: "casadi::cofactor"
// cWrapperName: "cofactor__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
// retType: CDouble
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "double"
// proto: "double cofactor__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// call: "casadi::cofactor(x0_, x1_, x2_)"
extern "C"
    double cofactor__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2);
double cofactor__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        double ret = casadi::cofactor(x0_, x1_, x2_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cofactor" ===============
// cppName: "casadi::cofactor"
// cWrapperName: "cofactor__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
// retType: CInt
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "int"
// proto: "int cofactor__2(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// call: "casadi::cofactor(x0_, x1_, x2_)"
extern "C"
    int cofactor__2(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2);
int cofactor__2(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        int ret = casadi::cofactor(x0_, x1_, x2_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::complement" ===============
// cppName: "casadi::complement"
// cWrapperName: "complement"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, int x1)"
// params: [Ref (Const (StdVec CInt)),CInt]
// retType: StdVec CInt
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* complement(std::string ** err_msg, std::vector< int >* x0, int x1)"
// call: "casadi::complement(x0_, x1_)"
extern "C"
    std::vector< int >* complement(std::string ** err_msg, std::vector< int >* x0, int x1);
std::vector< int >* complement(std::string ** err_msg, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< int > ret = casadi::complement(x0_, x1_);
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::compress" ===============
// cppName: "casadi::compress"
// cWrapperName: "compress__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
// retType: CVoid
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void compress__0(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::compress(x0_)"
extern "C"
    void compress__0(std::string ** err_msg, casadi::SX* x0);
void compress__0(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    casadi::compress(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::compress" ===============
// cppName: "casadi::compress"
// cWrapperName: "compress__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CInt]
// retType: CVoid
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void compress__1(std::string ** err_msg, casadi::SX* x0, int x1)"
// call: "casadi::compress(x0_, x1_)"
extern "C"
    void compress__1(std::string ** err_msg, casadi::SX* x0, int x1);
void compress__1(std::string ** err_msg, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    casadi::compress(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::controldaeIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* controldaeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::controldaeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* controldaeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::controldaeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* controldaeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* controldaeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* controldaeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* controldaeIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* controldaeIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* controldaeIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* controldaeIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controldaeIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* controldaeIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* controldaeIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::controldaeIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* controldaeIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::controldaeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* controldaeIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::controldaeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* controldaeIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* controldaeIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* controldaeIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* controldaeIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* controldaeIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* controldaeIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* controldaeIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controldaeIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* controldaeIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* controldaeIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::controldaeIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* controldaeIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::controldaeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* controldaeIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::controldaeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* controldaeIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* controldaeIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* controldaeIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* controldaeIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* controldaeIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* controldaeIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* controldaeIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controldaeIn" ===============
// cppName: "casadi::controldaeIn"
// cWrapperName: "controldaeIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controldaeIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* controldaeIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* controldaeIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::controldaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controlsimulatorIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::controlsimulatorIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* controlsimulatorIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* controlsimulatorIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::controlsimulatorIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controlsimulatorIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::controlsimulatorIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* controlsimulatorIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* controlsimulatorIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::controlsimulatorIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controlsimulatorIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::controlsimulatorIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* controlsimulatorIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* controlsimulatorIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::controlsimulatorIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* controlsimulatorIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::controlsimulatorIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* controlsimulatorIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* controlsimulatorIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::controlsimulatorIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controlsimulatorIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::controlsimulatorIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* controlsimulatorIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* controlsimulatorIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::controlsimulatorIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controlsimulatorIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::controlsimulatorIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* controlsimulatorIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* controlsimulatorIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::controlsimulatorIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controlsimulatorIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::controlsimulatorIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* controlsimulatorIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* controlsimulatorIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::controlsimulatorIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* controlsimulatorIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::controlsimulatorIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* controlsimulatorIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* controlsimulatorIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::controlsimulatorIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controlsimulatorIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::controlsimulatorIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* controlsimulatorIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* controlsimulatorIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::controlsimulatorIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controlsimulatorIn__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::controlsimulatorIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* controlsimulatorIn__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* controlsimulatorIn__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::controlsimulatorIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controlsimulatorIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::controlsimulatorIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* controlsimulatorIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* controlsimulatorIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::controlsimulatorIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::controlsimulatorIn" ===============
// cppName: "casadi::controlsimulatorIn"
// cWrapperName: "controlsimulatorIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* controlsimulatorIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::controlsimulatorIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* controlsimulatorIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* controlsimulatorIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::controlsimulatorIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::countNodes" ===============
// cppName: "casadi::countNodes"
// cWrapperName: "countNodes__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int countNodes__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::countNodes(x0_)"
extern "C"
    int countNodes__0(std::string ** err_msg, casadi::MX* x0);
int countNodes__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        int ret = casadi::countNodes(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::countNodes" ===============
// cppName: "casadi::countNodes"
// cWrapperName: "countNodes__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int countNodes__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::countNodes(x0_)"
extern "C"
    int countNodes__1(std::string ** err_msg, casadi::SX* x0);
int countNodes__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        int ret = casadi::countNodes(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::createParent" ===============
// cppName: "casadi::createParent"
// cWrapperName: "createParent__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::vector< casadi::MX* >* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* createParent__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::vector< casadi::MX* >* x1)"
// call: "casadi::createParent(x0_, x1_)"
extern "C"
    casadi::MX* createParent__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::vector< casadi::MX* >* x1);
casadi::MX* createParent__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::vector< casadi::MX* >* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);

        casadi::MX ret = casadi::createParent(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::createParent" ===============
// cppName: "casadi::createParent"
// cWrapperName: "createParent__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* createParent__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
// call: "casadi::createParent(x0_, x1_)"
extern "C"
    casadi::MX* createParent__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1);
casadi::MX* createParent__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);

        casadi::MX ret = casadi::createParent(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::createParent" ===============
// cppName: "casadi::createParent"
// cWrapperName: "createParent__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* createParent__2(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::createParent(x0_)"
extern "C"
    casadi::MX* createParent__2(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* createParent__2(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::createParent(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* cross__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::cross(x0_, x1_)"
extern "C"
    casadi::MX* cross__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* cross__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::cross(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* cross__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2)"
// call: "casadi::cross(x0_, x1_, x2_)"
extern "C"
    casadi::MX* cross__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2);
casadi::MX* cross__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::MX ret = casadi::cross(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* cross__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::cross(x0_, x1_)"
extern "C"
    casadi::SX* cross__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* cross__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::cross(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* cross__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2)"
// call: "casadi::cross(x0_, x1_, x2_)"
extern "C"
    casadi::SX* cross__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2);
casadi::SX* cross__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::cross(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* cross__4(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::cross(x0_, x1_)"
extern "C"
    casadi::DMatrix* cross__4(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* cross__4(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::cross(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* cross__5(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2)"
// call: "casadi::cross(x0_, x1_, x2_)"
extern "C"
    casadi::DMatrix* cross__5(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2);
casadi::DMatrix* cross__5(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::DMatrix ret = casadi::cross(x0_, x1_, x2_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__6"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* cross__6(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::cross(x0_, x1_)"
extern "C"
    casadi::IMatrix* cross__6(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* cross__6(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::cross(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::cross" ===============
// cppName: "casadi::cross"
// cWrapperName: "cross__7"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* cross__7(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2)"
// call: "casadi::cross(x0_, x1_, x2_)"
extern "C"
    casadi::IMatrix* cross__7(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2);
casadi::IMatrix* cross__7(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::IMatrix ret = casadi::cross(x0_, x1_, x2_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::daeIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* daeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::daeIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::daeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* daeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::daeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::daeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* daeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::daeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::daeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* daeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::daeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::daeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* daeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::daeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::daeIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* daeIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* daeIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::daeIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::daeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* daeIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* daeIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::daeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::daeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* daeIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* daeIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::daeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::daeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* daeIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* daeIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::daeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::daeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* daeIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* daeIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::daeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::daeIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* daeIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* daeIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::daeIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::daeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* daeIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* daeIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::daeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeIn__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::daeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* daeIn__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* daeIn__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::daeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeIn__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::daeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* daeIn__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* daeIn__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::daeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeIn" ===============
// cppName: "casadi::daeIn"
// cWrapperName: "daeIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::daeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* daeIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* daeIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::daeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::daeOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* daeOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::daeOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::daeOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* daeOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::daeOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::daeOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* daeOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::daeOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* daeOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::daeOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* daeOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* daeOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::daeOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::daeOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* daeOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* daeOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::daeOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::daeOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* daeOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* daeOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::daeOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::daeOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* daeOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* daeOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::daeOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* daeOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::daeOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* daeOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* daeOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::daeOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::daeOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* daeOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* daeOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::daeOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::daeOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* daeOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* daeOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::daeOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::daeOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* daeOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* daeOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::daeOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::daeOut" ===============
// cppName: "casadi::daeOut"
// cWrapperName: "daeOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* daeOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::daeOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* daeOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* daeOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::daeOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dense" ===============
// cppName: "casadi::dense"
// cWrapperName: "dense__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* dense__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::dense(x0_)"
extern "C"
    casadi::MX* dense__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* dense__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::dense(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dense" ===============
// cppName: "casadi::dense"
// cWrapperName: "dense__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* dense__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::dense(x0_)"
extern "C"
    casadi::SX* dense__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* dense__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::dense(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dense" ===============
// cppName: "casadi::dense"
// cWrapperName: "dense__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* dense__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::dense(x0_)"
extern "C"
    casadi::DMatrix* dense__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* dense__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::dense(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dense" ===============
// cppName: "casadi::dense"
// cWrapperName: "dense__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* dense__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::dense(x0_)"
extern "C"
    casadi::IMatrix* dense__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* dense__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::dense(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dependsOn" ===============
// cppName: "casadi::dependsOn"
// cWrapperName: "dependsOn__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: CBool
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int dependsOn__0(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1)"
// call: "casadi::dependsOn(x0_, x1_)"
extern "C"
    int dependsOn__0(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1);
int dependsOn__0(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);

        bool ret = casadi::dependsOn(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dependsOn" ===============
// cppName: "casadi::dependsOn"
// cWrapperName: "dependsOn__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CBool
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int dependsOn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::dependsOn(x0_, x1_)"
extern "C"
    int dependsOn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
int dependsOn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        bool ret = casadi::dependsOn(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::det" ===============
// cppName: "casadi::det"
// cWrapperName: "det__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* det__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::det(x0_)"
extern "C"
    casadi::MX* det__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* det__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::det(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::det" ===============
// cppName: "casadi::det"
// cWrapperName: "det__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* det__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::det(x0_)"
extern "C"
    casadi::SXElement* det__1(std::string ** err_msg, casadi::SX* x0);
casadi::SXElement* det__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SXElement ret = casadi::det(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::det" ===============
// cppName: "casadi::det"
// cWrapperName: "det__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: CDouble
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double det__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::det(x0_)"
extern "C"
    double det__2(std::string ** err_msg, casadi::DMatrix* x0);
double det__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        double ret = casadi::det(x0_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::det" ===============
// cppName: "casadi::det"
// cWrapperName: "det__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int det__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::det(x0_)"
extern "C"
    int det__3(std::string ** err_msg, casadi::IMatrix* x0);
int det__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        int ret = casadi::det(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::diag" ===============
// cppName: "casadi::diag"
// cWrapperName: "diag__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* diag__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::diag(x0_)"
extern "C"
    casadi::MX* diag__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* diag__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::diag(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::diag" ===============
// cppName: "casadi::diag"
// cWrapperName: "diag__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* diag__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::diag(x0_)"
extern "C"
    casadi::SX* diag__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* diag__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::diag(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::diag" ===============
// cppName: "casadi::diag"
// cWrapperName: "diag__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* diag__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::diag(x0_)"
extern "C"
    casadi::DMatrix* diag__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* diag__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::diag(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::diag" ===============
// cppName: "casadi::diag"
// cWrapperName: "diag__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* diag__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::diag(x0_)"
extern "C"
    casadi::IMatrix* diag__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* diag__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::diag(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* dpleIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::dpleIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* dpleIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* dpleIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::dpleIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* dpleIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::dpleIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* dpleIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* dpleIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::dpleIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* dpleIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::dpleIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* dpleIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* dpleIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::dpleIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* dpleIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::dpleIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* dpleIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* dpleIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::dpleIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* dpleIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::dpleIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* dpleIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* dpleIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::dpleIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* dpleIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::dpleIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* dpleIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* dpleIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::dpleIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* dpleIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::dpleIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* dpleIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* dpleIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::dpleIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* dpleIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::dpleIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* dpleIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* dpleIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::dpleIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleIn" ===============
// cppName: "casadi::dpleIn"
// cWrapperName: "dpleIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* dpleIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::dpleIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* dpleIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* dpleIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::dpleIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleOut" ===============
// cppName: "casadi::dpleOut"
// cWrapperName: "dpleOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* dpleOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::dpleOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* dpleOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* dpleOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::dpleOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleOut" ===============
// cppName: "casadi::dpleOut"
// cWrapperName: "dpleOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* dpleOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::dpleOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* dpleOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* dpleOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::dpleOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleOut" ===============
// cppName: "casadi::dpleOut"
// cWrapperName: "dpleOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* dpleOut__2(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::dpleOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* dpleOut__2(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* dpleOut__2(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::dpleOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleOut" ===============
// cppName: "casadi::dpleOut"
// cWrapperName: "dpleOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* dpleOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::dpleOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* dpleOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* dpleOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::dpleOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleOut" ===============
// cppName: "casadi::dpleOut"
// cWrapperName: "dpleOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* dpleOut__4(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::dpleOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* dpleOut__4(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* dpleOut__4(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::dpleOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::dpleOut" ===============
// cppName: "casadi::dpleOut"
// cWrapperName: "dpleOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* dpleOut__5(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::dpleOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* dpleOut__5(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* dpleOut__5(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::dpleOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::eig_symbolic" ===============
// cppName: "casadi::eig_symbolic"
// cWrapperName: "eig_symbolic"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* eig_symbolic(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::eig_symbolic(x0_)"
extern "C"
    casadi::SX* eig_symbolic(std::string ** err_msg, casadi::SX* x0);
casadi::SX* eig_symbolic(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::eig_symbolic(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::evalf" ===============
// cppName: "casadi::evalf"
// cWrapperName: "evalf__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::DMatrix* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* evalf__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::DMatrix* x2)"
// call: "casadi::evalf(x0_, x1_, x2_)"
extern "C"
    casadi::DMatrix* evalf__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::DMatrix* x2);
casadi::DMatrix* evalf__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::DMatrix* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

        casadi::DMatrix ret = casadi::evalf(x0_, x1_, x2_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::evalf" ===============
// cppName: "casadi::evalf"
// cWrapperName: "evalf__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* evalf__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::evalf(x0_)"
extern "C"
    casadi::DMatrix* evalf__1(std::string ** err_msg, casadi::SX* x0);
casadi::DMatrix* evalf__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::DMatrix ret = casadi::evalf(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::expand" ===============
// cppName: "casadi::expand"
// cWrapperName: "expand"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX")),Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void expand(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::expand(x0_, x1_, x2_)"
extern "C"
    void expand(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
void expand(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

    casadi::expand(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::extractShared" ===============
// cppName: "casadi::extractShared"
// cWrapperName: "extractShared__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void extractShared__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// call: "casadi::extractShared(x0_, x1_, x2_)"
extern "C"
    void extractShared__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2);
void extractShared__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);

    casadi::extractShared(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::extractShared" ===============
// cppName: "casadi::extractShared"
// cWrapperName: "extractShared__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void extractShared__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3)"
// call: "casadi::extractShared(x0_, x1_, x2_, x3_)"
extern "C"
    void extractShared__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3);
void extractShared__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

    casadi::extractShared(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::extractShared" ===============
// cppName: "casadi::extractShared"
// cWrapperName: "extractShared__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3, std::string* x4)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString),Ref (Const StdString)]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "void"
// proto: "void extractShared__2(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3, std::string* x4)"
// call: "casadi::extractShared(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    void extractShared__2(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3, std::string* x4);
void extractShared__2(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

    casadi::extractShared(x0_, x1_, x2_, x3_, x4_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::extractShared" ===============
// cppName: "casadi::extractShared"
// cWrapperName: "extractShared__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void extractShared__3(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// call: "casadi::extractShared(x0_, x1_, x2_)"
extern "C"
    void extractShared__3(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2);
void extractShared__3(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        std::vector< casadi::SXElement > x1_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);

    casadi::extractShared(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::extractShared" ===============
// cppName: "casadi::extractShared"
// cWrapperName: "extractShared__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const StdString)]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void extractShared__4(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3)"
// call: "casadi::extractShared(x0_, x1_, x2_, x3_)"
extern "C"
    void extractShared__4(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3);
void extractShared__4(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        std::vector< casadi::SXElement > x1_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

    casadi::extractShared(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::extractShared" ===============
// cppName: "casadi::extractShared"
// cWrapperName: "extractShared__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3, std::string* x4)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const StdString),Ref (Const StdString)]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "void"
// proto: "void extractShared__5(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3, std::string* x4)"
// call: "casadi::extractShared(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    void extractShared__5(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3, std::string* x4);
void extractShared__5(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        std::vector< casadi::SXElement > x1_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

    casadi::extractShared(x0_, x1_, x2_, x3_, x4_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::gauss_quadrature" ===============
// cppName: "casadi::gauss_quadrature"
// cWrapperName: "gauss_quadrature__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3)"
// params: [UserType (Namespace ["casadi"]) (Name "SX"),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* gauss_quadrature__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3)"
// call: "casadi::gauss_quadrature(x0_, x1_, x2_, x3_)"
extern "C"
    casadi::SX* gauss_quadrature__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3);
casadi::SX* gauss_quadrature__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        casadi::SX x3_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x3);

        casadi::SX ret = casadi::gauss_quadrature(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gauss_quadrature" ===============
// cppName: "casadi::gauss_quadrature"
// cWrapperName: "gauss_quadrature__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4)"
// params: [UserType (Namespace ["casadi"]) (Name "SX"),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* gauss_quadrature__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4)"
// call: "casadi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    casadi::SX* gauss_quadrature__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4);
casadi::SX* gauss_quadrature__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        casadi::SX x3_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

        casadi::SX ret = casadi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gauss_quadrature" ===============
// cppName: "casadi::gauss_quadrature"
// cWrapperName: "gauss_quadrature__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4, casadi::SX* x5)"
// params: [UserType (Namespace ["casadi"]) (Name "SX"),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* gauss_quadrature__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4, casadi::SX* x5)"
// call: "casadi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    casadi::SX* gauss_quadrature__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4, casadi::SX* x5);
casadi::SX* gauss_quadrature__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3, int x4, casadi::SX* x5){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        casadi::SX x3_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);
        casadi::SX x5_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x5);

        casadi::SX ret = casadi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getFree" ===============
// cppName: "casadi::getFree"
// cWrapperName: "getFree"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* getFree(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::getFree(x0_)"
extern "C"
    casadi::SX* getFree(std::string ** err_msg, casadi::SX* x0);
casadi::SX* getFree(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::getFree(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getMinor" ===============
// cppName: "casadi::getMinor"
// cWrapperName: "getMinor__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* getMinor__0(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// call: "casadi::getMinor(x0_, x1_, x2_)"
extern "C"
    casadi::SXElement* getMinor__0(std::string ** err_msg, casadi::SX* x0, int x1, int x2);
casadi::SXElement* getMinor__0(std::string ** err_msg, casadi::SX* x0, int x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SXElement ret = casadi::getMinor(x0_, x1_, x2_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getMinor" ===============
// cppName: "casadi::getMinor"
// cWrapperName: "getMinor__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
// retType: CDouble
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "double"
// proto: "double getMinor__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// call: "casadi::getMinor(x0_, x1_, x2_)"
extern "C"
    double getMinor__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2);
double getMinor__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        double ret = casadi::getMinor(x0_, x1_, x2_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getMinor" ===============
// cppName: "casadi::getMinor"
// cWrapperName: "getMinor__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
// retType: CInt
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "int"
// proto: "int getMinor__2(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// call: "casadi::getMinor(x0_, x1_, x2_)"
extern "C"
    int getMinor__2(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2);
int getMinor__2(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        int ret = casadi::getMinor(x0_, x1_, x2_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getOperatorRepresentation" ===============
// cppName: "casadi::getOperatorRepresentation"
// cWrapperName: "getOperatorRepresentation__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< std::string* >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec StdString))]
// retType: StdString
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getOperatorRepresentation__0(std::string ** err_msg, casadi::MX* x0, std::vector< std::string* >* x1)"
// call: "casadi::getOperatorRepresentation(x0_, x1_)"
extern "C"
    std::string* getOperatorRepresentation__0(std::string ** err_msg, casadi::MX* x0, std::vector< std::string* >* x1);
std::string* getOperatorRepresentation__0(std::string ** err_msg, casadi::MX* x0, std::vector< std::string* >* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);

        std::string ret = casadi::getOperatorRepresentation(x0_, x1_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getOperatorRepresentation" ===============
// cppName: "casadi::getOperatorRepresentation"
// cWrapperName: "getOperatorRepresentation__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* x0, std::vector< std::string* >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const (StdVec StdString))]
// retType: StdString
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getOperatorRepresentation__1(std::string ** err_msg, casadi::SXElement* x0, std::vector< std::string* >* x1)"
// call: "casadi::getOperatorRepresentation(x0_, x1_)"
extern "C"
    std::string* getOperatorRepresentation__1(std::string ** err_msg, casadi::SXElement* x0, std::vector< std::string* >* x1);
std::string* getOperatorRepresentation__1(std::string ** err_msg, casadi::SXElement* x0, std::vector< std::string* >* x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);

        std::string ret = casadi::getOperatorRepresentation(x0_, x1_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeEntryDoc" ===============
// cppName: "casadi::getSchemeEntryDoc"
// cWrapperName: "getSchemeEntryDoc"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme"),CInt]
// retType: StdString
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getSchemeEntryDoc(std::string ** err_msg, int x0, int x1)"
// call: "casadi::getSchemeEntryDoc(x0_, x1_)"
extern "C"
    std::string* getSchemeEntryDoc(std::string ** err_msg, int x0, int x1);
std::string* getSchemeEntryDoc(std::string ** err_msg, int x0, int x1){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::string ret = casadi::getSchemeEntryDoc(x0_, x1_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeEntryEnum" ===============
// cppName: "casadi::getSchemeEntryEnum"
// cWrapperName: "getSchemeEntryEnum"
// protoArgs: "(std::string ** err_msg, int x0, std::string* x1)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme"),Ref (Const StdString)]
// retType: CInt
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int getSchemeEntryEnum(std::string ** err_msg, int x0, std::string* x1)"
// call: "casadi::getSchemeEntryEnum(x0_, x1_)"
extern "C"
    int getSchemeEntryEnum(std::string ** err_msg, int x0, std::string* x1);
int getSchemeEntryEnum(std::string ** err_msg, int x0, std::string* x1){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        int ret = casadi::getSchemeEntryEnum(x0_, x1_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeEntryEnumName" ===============
// cppName: "casadi::getSchemeEntryEnumName"
// cWrapperName: "getSchemeEntryEnumName"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme"),CInt]
// retType: StdString
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getSchemeEntryEnumName(std::string ** err_msg, int x0, int x1)"
// call: "casadi::getSchemeEntryEnumName(x0_, x1_)"
extern "C"
    std::string* getSchemeEntryEnumName(std::string ** err_msg, int x0, int x1);
std::string* getSchemeEntryEnumName(std::string ** err_msg, int x0, int x1){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::string ret = casadi::getSchemeEntryEnumName(x0_, x1_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeEntryName" ===============
// cppName: "casadi::getSchemeEntryName"
// cWrapperName: "getSchemeEntryName"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme"),CInt]
// retType: StdString
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getSchemeEntryName(std::string ** err_msg, int x0, int x1)"
// call: "casadi::getSchemeEntryName(x0_, x1_)"
extern "C"
    std::string* getSchemeEntryName(std::string ** err_msg, int x0, int x1);
std::string* getSchemeEntryName(std::string ** err_msg, int x0, int x1){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::string ret = casadi::getSchemeEntryName(x0_, x1_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeEntryNames" ===============
// cppName: "casadi::getSchemeEntryNames"
// cWrapperName: "getSchemeEntryNames"
// protoArgs: "(std::string ** err_msg, int x0)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme")]
// retType: StdString
// args: "(x0_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getSchemeEntryNames(std::string ** err_msg, int x0)"
// call: "casadi::getSchemeEntryNames(x0_)"
extern "C"
    std::string* getSchemeEntryNames(std::string ** err_msg, int x0);
std::string* getSchemeEntryNames(std::string ** err_msg, int x0){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);

        std::string ret = casadi::getSchemeEntryNames(x0_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeName" ===============
// cppName: "casadi::getSchemeName"
// cWrapperName: "getSchemeName"
// protoArgs: "(std::string ** err_msg, int x0)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme")]
// retType: StdString
// args: "(x0_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* getSchemeName(std::string ** err_msg, int x0)"
// call: "casadi::getSchemeName(x0_)"
extern "C"
    std::string* getSchemeName(std::string ** err_msg, int x0);
std::string* getSchemeName(std::string ** err_msg, int x0){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);

        std::string ret = casadi::getSchemeName(x0_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSchemeSize" ===============
// cppName: "casadi::getSchemeSize"
// cWrapperName: "getSchemeSize"
// protoArgs: "(std::string ** err_msg, int x0)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme")]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int getSchemeSize(std::string ** err_msg, int x0)"
// call: "casadi::getSchemeSize(x0_)"
extern "C"
    int getSchemeSize(std::string ** err_msg, int x0);
int getSchemeSize(std::string ** err_msg, int x0){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);

        int ret = casadi::getSchemeSize(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSymbols" ===============
// cppName: "casadi::getSymbols"
// cWrapperName: "getSymbols__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* getSymbols__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::getSymbols(x0_)"
extern "C"
    std::vector< casadi::MX* >* getSymbols__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* getSymbols__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::getSymbols(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSymbols" ===============
// cppName: "casadi::getSymbols"
// cWrapperName: "getSymbols__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* getSymbols__1(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::getSymbols(x0_)"
extern "C"
    std::vector< casadi::MX* >* getSymbols__1(std::string ** err_msg, casadi::MX* x0);
std::vector< casadi::MX* >* getSymbols__1(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::getSymbols(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::getSymbols" ===============
// cppName: "casadi::getSymbols"
// cWrapperName: "getSymbols__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SXElement* >*"
// proto: "std::vector< casadi::SXElement* >* getSymbols__2(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::getSymbols(x0_)"
extern "C"
    std::vector< casadi::SXElement* >* getSymbols__2(std::string ** err_msg, casadi::SX* x0);
std::vector< casadi::SXElement* >* getSymbols__2(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        std::vector< casadi::SXElement > ret = casadi::getSymbols(x0_);
        return WrapReturn< std::vector< casadi::SXElement* >*, std::vector< casadi::SXElement > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::gradFIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* gradFIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::gradFIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::gradFIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* gradFIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::gradFIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::gradFIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* gradFIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::gradFIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::gradFIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* gradFIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* gradFIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::gradFIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::gradFIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* gradFIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* gradFIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::gradFIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::gradFIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* gradFIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* gradFIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::gradFIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::gradFIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* gradFIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* gradFIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::gradFIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::gradFIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* gradFIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* gradFIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::gradFIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFIn" ===============
// cppName: "casadi::gradFIn"
// cWrapperName: "gradFIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::gradFIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* gradFIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* gradFIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::gradFIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::gradFOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* gradFOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::gradFOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::gradFOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* gradFOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::gradFOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::gradFOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* gradFOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::gradFOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* gradFOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::gradFOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* gradFOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* gradFOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::gradFOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::gradFOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* gradFOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* gradFOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::gradFOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::gradFOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* gradFOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* gradFOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::gradFOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::gradFOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* gradFOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* gradFOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::gradFOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* gradFOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::gradFOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* gradFOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* gradFOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::gradFOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::gradFOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* gradFOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* gradFOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::gradFOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::gradFOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* gradFOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* gradFOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::gradFOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::gradFOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* gradFOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* gradFOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::gradFOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradFOut" ===============
// cppName: "casadi::gradFOut"
// cWrapperName: "gradFOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* gradFOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::gradFOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* gradFOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* gradFOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::gradFOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradient" ===============
// cppName: "casadi::gradient"
// cWrapperName: "gradient__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* gradient__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::gradient(x0_, x1_)"
extern "C"
    casadi::MX* gradient__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* gradient__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::gradient(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::gradient" ===============
// cppName: "casadi::gradient"
// cWrapperName: "gradient__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* gradient__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::gradient(x0_, x1_)"
extern "C"
    casadi::SX* gradient__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* gradient__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::gradient(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::graph_substitute" ===============
// cppName: "casadi::graph_substitute"
// cWrapperName: "graph_substitute__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* graph_substitute__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// call: "casadi::graph_substitute(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* graph_substitute__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2);
std::vector< casadi::MX* >* graph_substitute__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::graph_substitute(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::graph_substitute" ===============
// cppName: "casadi::graph_substitute"
// cWrapperName: "graph_substitute__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* graph_substitute__1(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// call: "casadi::graph_substitute(x0_, x1_, x2_)"
extern "C"
    casadi::MX* graph_substitute__1(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2);
casadi::MX* graph_substitute__1(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);

        casadi::MX ret = casadi::graph_substitute(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::heaviside" ===============
// cppName: "casadi::heaviside"
// cWrapperName: "heaviside"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* heaviside(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::heaviside(x0_)"
extern "C"
    casadi::SX* heaviside(std::string ** err_msg, casadi::SX* x0);
casadi::SX* heaviside(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::heaviside(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::hessLagIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* hessLagIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::hessLagIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::hessLagIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* hessLagIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::hessLagIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hessLagIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* hessLagIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::hessLagIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hessLagIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* hessLagIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::hessLagIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::hessLagIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* hessLagIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::hessLagIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::hessLagIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* hessLagIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* hessLagIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::hessLagIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::hessLagIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* hessLagIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* hessLagIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::hessLagIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hessLagIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* hessLagIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* hessLagIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::hessLagIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hessLagIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* hessLagIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* hessLagIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::hessLagIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::hessLagIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* hessLagIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* hessLagIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::hessLagIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::hessLagIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* hessLagIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* hessLagIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::hessLagIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::hessLagIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* hessLagIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* hessLagIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::hessLagIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagIn__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hessLagIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* hessLagIn__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* hessLagIn__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::hessLagIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagIn__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hessLagIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* hessLagIn__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* hessLagIn__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::hessLagIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagIn" ===============
// cppName: "casadi::hessLagIn"
// cWrapperName: "hessLagIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::hessLagIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* hessLagIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* hessLagIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::hessLagIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::hessLagOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* hessLagOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::hessLagOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::hessLagOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* hessLagOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::hessLagOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hessLagOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* hessLagOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::hessLagOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* hessLagOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* hessLagOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hessLagOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* hessLagOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* hessLagOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::hessLagOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* hessLagOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* hessLagOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::hessLagOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::hessLagOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* hessLagOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* hessLagOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::hessLagOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hessLagOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* hessLagOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* hessLagOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::hessLagOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* hessLagOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* hessLagOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* hessLagOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* hessLagOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hessLagOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* hessLagOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* hessLagOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::hessLagOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* hessLagOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* hessLagOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::hessLagOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::hessLagOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* hessLagOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* hessLagOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::hessLagOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hessLagOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* hessLagOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* hessLagOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::hessLagOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* hessLagOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* hessLagOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* hessLagOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* hessLagOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessLagOut" ===============
// cppName: "casadi::hessLagOut"
// cWrapperName: "hessLagOut__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hessLagOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* hessLagOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* hessLagOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::hessLagOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hessian" ===============
// cppName: "casadi::hessian"
// cWrapperName: "hessian__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX")),Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void hessian__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3)"
// call: "casadi::hessian(x0_, x1_, x2_, x3_)"
extern "C"
    void hessian__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3);
void hessian__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, casadi::SX* x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        casadi::SX x3_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x3);

    casadi::hessian(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::hessian" ===============
// cppName: "casadi::hessian"
// cWrapperName: "hessian__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* hessian__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::hessian(x0_, x1_)"
extern "C"
    casadi::SX* hessian__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* hessian__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::hessian(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hnlpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::hnlpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* hnlpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* hnlpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::hnlpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hnlpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::hnlpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* hnlpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* hnlpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::hnlpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hnlpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hnlpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* hnlpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* hnlpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::hnlpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* hnlpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hnlpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* hnlpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* hnlpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::hnlpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hnlpIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::hnlpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* hnlpIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* hnlpIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::hnlpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hnlpIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::hnlpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* hnlpIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* hnlpIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::hnlpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hnlpIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hnlpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* hnlpIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* hnlpIn__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::hnlpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* hnlpIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hnlpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* hnlpIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* hnlpIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::hnlpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hnlpIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::hnlpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* hnlpIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* hnlpIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::hnlpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hnlpIn__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::hnlpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* hnlpIn__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* hnlpIn__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::hnlpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hnlpIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::hnlpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* hnlpIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* hnlpIn__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::hnlpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::hnlpIn" ===============
// cppName: "casadi::hnlpIn"
// cWrapperName: "hnlpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* hnlpIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::hnlpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* hnlpIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* hnlpIn__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::hnlpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzcat" ===============
// cppName: "casadi::horzcat"
// cWrapperName: "horzcat__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* horzcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::horzcat(x0_)"
extern "C"
    casadi::MX* horzcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* horzcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::horzcat(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzcat" ===============
// cppName: "casadi::horzcat"
// cWrapperName: "horzcat__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* horzcat__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::horzcat(x0_)"
extern "C"
    casadi::Sparsity* horzcat__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
casadi::Sparsity* horzcat__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        casadi::Sparsity ret = casadi::horzcat(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzcat" ===============
// cppName: "casadi::horzcat"
// cWrapperName: "horzcat__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* horzcat__2(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::horzcat(x0_)"
extern "C"
    casadi::SX* horzcat__2(std::string ** err_msg, std::vector< casadi::SX* >* x0);
casadi::SX* horzcat__2(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SX ret = casadi::horzcat(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzcat" ===============
// cppName: "casadi::horzcat"
// cWrapperName: "horzcat__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* horzcat__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// call: "casadi::horzcat(x0_)"
extern "C"
    casadi::DMatrix* horzcat__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0);
casadi::DMatrix* horzcat__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::horzcat(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzcat" ===============
// cppName: "casadi::horzcat"
// cWrapperName: "horzcat__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* horzcat__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// call: "casadi::horzcat(x0_)"
extern "C"
    casadi::IMatrix* horzcat__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0);
casadi::IMatrix* horzcat__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0){
    try {
        std::vector< casadi::IMatrix > x0_ = Marshaling<std::vector< casadi::IMatrix >,std::vector< casadi::IMatrix* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::horzcat(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* horzsplit__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::horzsplit(x0_)"
extern "C"
    std::vector< casadi::MX* >* horzsplit__0(std::string ** err_msg, casadi::MX* x0);
std::vector< casadi::MX* >* horzsplit__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::horzsplit(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* horzsplit__1(std::string ** err_msg, casadi::MX* x0, int x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* horzsplit__1(std::string ** err_msg, casadi::MX* x0, int x1);
std::vector< casadi::MX* >* horzsplit__1(std::string ** err_msg, casadi::MX* x0, int x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* horzsplit__2(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* horzsplit__2(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1);
std::vector< casadi::MX* >* horzsplit__2(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* horzsplit__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* horzsplit__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1);
std::vector< casadi::Sparsity* >* horzsplit__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* horzsplit__4(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::horzsplit(x0_)"
extern "C"
    std::vector< casadi::SX* >* horzsplit__4(std::string ** err_msg, casadi::SX* x0);
std::vector< casadi::SX* >* horzsplit__4(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::horzsplit(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* horzsplit__5(std::string ** err_msg, casadi::SX* x0, int x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* horzsplit__5(std::string ** err_msg, casadi::SX* x0, int x1);
std::vector< casadi::SX* >* horzsplit__5(std::string ** err_msg, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__6"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* horzsplit__6(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* horzsplit__6(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1);
std::vector< casadi::SX* >* horzsplit__6(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__7"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* horzsplit__7(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::horzsplit(x0_)"
extern "C"
    std::vector< casadi::DMatrix* >* horzsplit__7(std::string ** err_msg, casadi::DMatrix* x0);
std::vector< casadi::DMatrix* >* horzsplit__7(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        std::vector< casadi::DMatrix > ret = casadi::horzsplit(x0_);
        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__8"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* horzsplit__8(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::DMatrix* >* horzsplit__8(std::string ** err_msg, casadi::DMatrix* x0, int x1);
std::vector< casadi::DMatrix* >* horzsplit__8(std::string ** err_msg, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::DMatrix > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__9"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* horzsplit__9(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::DMatrix* >* horzsplit__9(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1);
std::vector< casadi::DMatrix* >* horzsplit__9(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::DMatrix > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__10"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* horzsplit__10(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::horzsplit(x0_)"
extern "C"
    std::vector< casadi::IMatrix* >* horzsplit__10(std::string ** err_msg, casadi::IMatrix* x0);
std::vector< casadi::IMatrix* >* horzsplit__10(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        std::vector< casadi::IMatrix > ret = casadi::horzsplit(x0_);
        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__11"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* horzsplit__11(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::IMatrix* >* horzsplit__11(std::string ** err_msg, casadi::IMatrix* x0, int x1);
std::vector< casadi::IMatrix* >* horzsplit__11(std::string ** err_msg, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::IMatrix > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::horzsplit" ===============
// cppName: "casadi::horzsplit"
// cWrapperName: "horzsplit__12"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* horzsplit__12(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "casadi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::IMatrix* >* horzsplit__12(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1);
std::vector< casadi::IMatrix* >* horzsplit__12(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::IMatrix > ret = casadi::horzsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::if_else" ===============
// cppName: "casadi::if_else"
// cWrapperName: "if_else__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* if_else__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2)"
// call: "casadi::if_else(x0_, x1_, x2_)"
extern "C"
    casadi::MX* if_else__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2);
casadi::MX* if_else__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

        casadi::MX ret = casadi::if_else(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::if_else" ===============
// cppName: "casadi::if_else"
// cWrapperName: "if_else__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* if_else__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::if_else(x0_, x1_, x2_)"
extern "C"
    casadi::SX* if_else__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* if_else__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::if_else(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inner_prod" ===============
// cppName: "casadi::inner_prod"
// cWrapperName: "inner_prod__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* inner_prod__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::inner_prod(x0_, x1_)"
extern "C"
    casadi::MX* inner_prod__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* inner_prod__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::inner_prod(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inner_prod" ===============
// cppName: "casadi::inner_prod"
// cWrapperName: "inner_prod__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* inner_prod__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::inner_prod(x0_, x1_)"
extern "C"
    casadi::SX* inner_prod__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* inner_prod__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::inner_prod(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inner_prod" ===============
// cppName: "casadi::inner_prod"
// cWrapperName: "inner_prod__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* inner_prod__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::inner_prod(x0_, x1_)"
extern "C"
    casadi::DMatrix* inner_prod__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* inner_prod__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::inner_prod(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inner_prod" ===============
// cppName: "casadi::inner_prod"
// cWrapperName: "inner_prod__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* inner_prod__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::inner_prod(x0_, x1_)"
extern "C"
    casadi::IMatrix* inner_prod__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* inner_prod__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::inner_prod(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::integratorIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* integratorIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::integratorIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* integratorIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::integratorIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* integratorIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* integratorIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* integratorIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* integratorIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* integratorIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::integratorIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* integratorIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::integratorIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* integratorIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::integratorIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* integratorIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* integratorIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* integratorIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* integratorIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* integratorIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* integratorIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::integratorIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* integratorIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::integratorIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* integratorIn__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::integratorIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* integratorIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* integratorIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* integratorIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* integratorIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorIn" ===============
// cppName: "casadi::integratorIn"
// cWrapperName: "integratorIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* integratorIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* integratorIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::integratorIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::integratorOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* integratorOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::integratorOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* integratorOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::integratorOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* integratorOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* integratorOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* integratorOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* integratorOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* integratorOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* integratorOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* integratorOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::integratorOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* integratorOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::integratorOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* integratorOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::integratorOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* integratorOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* integratorOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* integratorOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* integratorOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* integratorOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* integratorOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* integratorOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::integratorOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* integratorOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::integratorOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* integratorOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::integratorOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* integratorOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* integratorOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* integratorOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* integratorOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::integratorOut" ===============
// cppName: "casadi::integratorOut"
// cWrapperName: "integratorOut__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* integratorOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* integratorOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* integratorOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::integratorOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inv" ===============
// cppName: "casadi::inv"
// cWrapperName: "inv__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* inv__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::inv(x0_)"
extern "C"
    casadi::MX* inv__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* inv__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::inv(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inv" ===============
// cppName: "casadi::inv"
// cWrapperName: "inv__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* inv__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::inv(x0_)"
extern "C"
    casadi::SX* inv__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* inv__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::inv(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inv" ===============
// cppName: "casadi::inv"
// cWrapperName: "inv__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* inv__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::inv(x0_)"
extern "C"
    casadi::DMatrix* inv__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* inv__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::inv(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::inv" ===============
// cppName: "casadi::inv"
// cWrapperName: "inv__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* inv__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::inv(x0_)"
extern "C"
    casadi::IMatrix* inv__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* inv__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::inv(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isDecreasing" ===============
// cppName: "casadi::isDecreasing"
// cWrapperName: "isDecreasing__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isDecreasing__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isDecreasing(x0_)"
extern "C"
    int isDecreasing__0(std::string ** err_msg, std::vector< double >* x0);
int isDecreasing__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isDecreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isDecreasing" ===============
// cppName: "casadi::isDecreasing"
// cWrapperName: "isDecreasing__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isDecreasing__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isDecreasing(x0_)"
extern "C"
    int isDecreasing__1(std::string ** err_msg, std::vector< int >* x0);
int isDecreasing__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isDecreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isEqual" ===============
// cppName: "casadi::isEqual"
// cWrapperName: "isEqual__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: CBool
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int isEqual__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::isEqual(x0_, x1_)"
extern "C"
    int isEqual__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
int isEqual__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        bool ret = casadi::isEqual(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isEqual" ===============
// cppName: "casadi::isEqual"
// cWrapperName: "isEqual__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CBool
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int isEqual__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::isEqual(x0_, x1_)"
extern "C"
    int isEqual__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
int isEqual__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        bool ret = casadi::isEqual(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isEqual" ===============
// cppName: "casadi::isEqual"
// cWrapperName: "isEqual__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: CBool
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int isEqual__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::isEqual(x0_, x1_)"
extern "C"
    int isEqual__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
int isEqual__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        bool ret = casadi::isEqual(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isEqual" ===============
// cppName: "casadi::isEqual"
// cWrapperName: "isEqual__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: CBool
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int isEqual__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::isEqual(x0_, x1_)"
extern "C"
    int isEqual__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
int isEqual__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        bool ret = casadi::isEqual(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isIncreasing" ===============
// cppName: "casadi::isIncreasing"
// cWrapperName: "isIncreasing__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isIncreasing__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isIncreasing(x0_)"
extern "C"
    int isIncreasing__0(std::string ** err_msg, std::vector< double >* x0);
int isIncreasing__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isIncreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isIncreasing" ===============
// cppName: "casadi::isIncreasing"
// cWrapperName: "isIncreasing__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isIncreasing__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isIncreasing(x0_)"
extern "C"
    int isIncreasing__1(std::string ** err_msg, std::vector< int >* x0);
int isIncreasing__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isIncreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isMonotone" ===============
// cppName: "casadi::isMonotone"
// cWrapperName: "isMonotone__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isMonotone__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isMonotone(x0_)"
extern "C"
    int isMonotone__0(std::string ** err_msg, std::vector< double >* x0);
int isMonotone__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isMonotone(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isMonotone" ===============
// cppName: "casadi::isMonotone"
// cWrapperName: "isMonotone__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isMonotone__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isMonotone(x0_)"
extern "C"
    int isMonotone__1(std::string ** err_msg, std::vector< int >* x0);
int isMonotone__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isMonotone(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isNonDecreasing" ===============
// cppName: "casadi::isNonDecreasing"
// cWrapperName: "isNonDecreasing__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isNonDecreasing__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isNonDecreasing(x0_)"
extern "C"
    int isNonDecreasing__0(std::string ** err_msg, std::vector< double >* x0);
int isNonDecreasing__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isNonDecreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isNonDecreasing" ===============
// cppName: "casadi::isNonDecreasing"
// cWrapperName: "isNonDecreasing__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isNonDecreasing__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isNonDecreasing(x0_)"
extern "C"
    int isNonDecreasing__1(std::string ** err_msg, std::vector< int >* x0);
int isNonDecreasing__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isNonDecreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isNonIncreasing" ===============
// cppName: "casadi::isNonIncreasing"
// cWrapperName: "isNonIncreasing__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isNonIncreasing__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isNonIncreasing(x0_)"
extern "C"
    int isNonIncreasing__0(std::string ** err_msg, std::vector< double >* x0);
int isNonIncreasing__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isNonIncreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isNonIncreasing" ===============
// cppName: "casadi::isNonIncreasing"
// cWrapperName: "isNonIncreasing__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isNonIncreasing__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isNonIncreasing(x0_)"
extern "C"
    int isNonIncreasing__1(std::string ** err_msg, std::vector< int >* x0);
int isNonIncreasing__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isNonIncreasing(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isRegular" ===============
// cppName: "casadi::isRegular"
// cWrapperName: "isRegular__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isRegular__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isRegular(x0_)"
extern "C"
    int isRegular__0(std::string ** err_msg, std::vector< double >* x0);
int isRegular__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isRegular(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isRegular" ===============
// cppName: "casadi::isRegular"
// cWrapperName: "isRegular__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isRegular__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isRegular(x0_)"
extern "C"
    int isRegular__1(std::string ** err_msg, std::vector< int >* x0);
int isRegular__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isRegular(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isStrictlyMonotone" ===============
// cppName: "casadi::isStrictlyMonotone"
// cWrapperName: "isStrictlyMonotone__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// params: [Ref (Const (StdVec CDouble))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isStrictlyMonotone__0(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::isStrictlyMonotone(x0_)"
extern "C"
    int isStrictlyMonotone__0(std::string ** err_msg, std::vector< double >* x0);
int isStrictlyMonotone__0(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        bool ret = casadi::isStrictlyMonotone(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::isStrictlyMonotone" ===============
// cppName: "casadi::isStrictlyMonotone"
// cWrapperName: "isStrictlyMonotone__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// params: [Ref (Const (StdVec CInt))]
// retType: CBool
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int isStrictlyMonotone__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::isStrictlyMonotone(x0_)"
extern "C"
    int isStrictlyMonotone__1(std::string ** err_msg, std::vector< int >* x0);
int isStrictlyMonotone__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        bool ret = casadi::isStrictlyMonotone(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::jacGIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* jacGIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::jacGIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::jacGIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* jacGIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::jacGIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::jacGIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* jacGIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::jacGIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::jacGIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* jacGIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* jacGIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::jacGIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::jacGIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* jacGIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* jacGIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::jacGIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::jacGIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* jacGIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* jacGIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::jacGIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::jacGIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* jacGIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* jacGIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::jacGIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::jacGIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* jacGIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* jacGIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::jacGIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGIn" ===============
// cppName: "casadi::jacGIn"
// cWrapperName: "jacGIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::jacGIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* jacGIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* jacGIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::jacGIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::jacGOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* jacGOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::jacGOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::jacGOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* jacGOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::jacGOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::jacGOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* jacGOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::jacGOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* jacGOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::jacGOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* jacGOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* jacGOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::jacGOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::jacGOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* jacGOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* jacGOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::jacGOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::jacGOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* jacGOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* jacGOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::jacGOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::jacGOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* jacGOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* jacGOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::jacGOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* jacGOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::jacGOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* jacGOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* jacGOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::jacGOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::jacGOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* jacGOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* jacGOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::jacGOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::jacGOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* jacGOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* jacGOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::jacGOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::jacGOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* jacGOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* jacGOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::jacGOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacGOut" ===============
// cppName: "casadi::jacGOut"
// cWrapperName: "jacGOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* jacGOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::jacGOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* jacGOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* jacGOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::jacGOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacobian" ===============
// cppName: "casadi::jacobian"
// cWrapperName: "jacobian__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* jacobian__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::jacobian(x0_, x1_)"
extern "C"
    casadi::MX* jacobian__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* jacobian__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::jacobian(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacobian" ===============
// cppName: "casadi::jacobian"
// cWrapperName: "jacobian__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* jacobian__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::jacobian(x0_, x1_)"
extern "C"
    casadi::SX* jacobian__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* jacobian__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::jacobian(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacobianTimesVector" ===============
// cppName: "casadi::jacobianTimesVector"
// cWrapperName: "jacobianTimesVector__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* jacobianTimesVector__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::jacobianTimesVector(x0_, x1_, x2_)"
extern "C"
    casadi::SX* jacobianTimesVector__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* jacobianTimesVector__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::jacobianTimesVector(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::jacobianTimesVector" ===============
// cppName: "casadi::jacobianTimesVector"
// cWrapperName: "jacobianTimesVector__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* jacobianTimesVector__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3)"
// call: "casadi::jacobianTimesVector(x0_, x1_, x2_, x3_)"
extern "C"
    casadi::SX* jacobianTimesVector__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3);
casadi::SX* jacobianTimesVector__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::SX ret = casadi::jacobianTimesVector(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::kron" ===============
// cppName: "casadi::kron"
// cWrapperName: "kron__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* kron__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::kron(x0_, x1_)"
extern "C"
    casadi::MX* kron__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* kron__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::kron(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::kron" ===============
// cppName: "casadi::kron"
// cWrapperName: "kron__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* kron__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::kron(x0_, x1_)"
extern "C"
    casadi::SX* kron__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* kron__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::kron(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::kron" ===============
// cppName: "casadi::kron"
// cWrapperName: "kron__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* kron__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::kron(x0_, x1_)"
extern "C"
    casadi::DMatrix* kron__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* kron__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::kron(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::kron" ===============
// cppName: "casadi::kron"
// cWrapperName: "kron__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* kron__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::kron(x0_, x1_)"
extern "C"
    casadi::IMatrix* kron__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* kron__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::kron(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* linsolIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::linsolIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* linsolIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* linsolIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::linsolIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* linsolIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::linsolIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* linsolIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* linsolIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::linsolIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* linsolIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::linsolIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* linsolIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* linsolIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::linsolIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* linsolIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::linsolIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* linsolIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* linsolIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::linsolIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* linsolIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::linsolIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* linsolIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* linsolIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::linsolIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* linsolIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::linsolIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* linsolIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* linsolIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::linsolIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* linsolIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::linsolIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* linsolIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* linsolIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::linsolIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* linsolIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::linsolIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* linsolIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* linsolIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::linsolIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolIn" ===============
// cppName: "casadi::linsolIn"
// cWrapperName: "linsolIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* linsolIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::linsolIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* linsolIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* linsolIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::linsolIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolOut" ===============
// cppName: "casadi::linsolOut"
// cWrapperName: "linsolOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* linsolOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::linsolOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* linsolOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* linsolOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::linsolOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolOut" ===============
// cppName: "casadi::linsolOut"
// cWrapperName: "linsolOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* linsolOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::linsolOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* linsolOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* linsolOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::linsolOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolOut" ===============
// cppName: "casadi::linsolOut"
// cWrapperName: "linsolOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* linsolOut__2(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::linsolOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* linsolOut__2(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* linsolOut__2(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::linsolOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolOut" ===============
// cppName: "casadi::linsolOut"
// cWrapperName: "linsolOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* linsolOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::linsolOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* linsolOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* linsolOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::linsolOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolOut" ===============
// cppName: "casadi::linsolOut"
// cWrapperName: "linsolOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* linsolOut__4(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::linsolOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* linsolOut__4(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* linsolOut__4(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::linsolOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linsolOut" ===============
// cppName: "casadi::linsolOut"
// cWrapperName: "linsolOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* linsolOut__5(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::linsolOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* linsolOut__5(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* linsolOut__5(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::linsolOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linspace" ===============
// cppName: "casadi::linspace"
// cWrapperName: "linspace__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* linspace__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2)"
// call: "casadi::linspace(x0_, x1_, x2_)"
extern "C"
    casadi::MX* linspace__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2);
casadi::MX* linspace__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, int x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::MX ret = casadi::linspace(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linspace" ===============
// cppName: "casadi::linspace"
// cWrapperName: "linspace__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* linspace__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2)"
// call: "casadi::linspace(x0_, x1_, x2_)"
extern "C"
    casadi::SX* linspace__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2);
casadi::SX* linspace__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::linspace(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::linspace" ===============
// cppName: "casadi::linspace"
// cWrapperName: "linspace__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* linspace__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2)"
// call: "casadi::linspace(x0_, x1_, x2_)"
extern "C"
    casadi::DMatrix* linspace__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2);
casadi::DMatrix* linspace__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::DMatrix ret = casadi::linspace(x0_, x1_, x2_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* logic_and__0(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    casadi::SXElement* logic_and__0(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1);
casadi::SXElement* logic_and__0(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

        casadi::SXElement ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* logic_and__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    casadi::MX* logic_and__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* logic_and__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* logic_and__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    casadi::SX* logic_and__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* logic_and__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* logic_and__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    casadi::DMatrix* logic_and__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* logic_and__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* logic_and__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    casadi::IMatrix* logic_and__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* logic_and__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__5"
// protoArgs: "(std::string ** err_msg, double* x0, double* x1)"
// params: [Ref (Const CDouble),Ref (Const CDouble)]
// retType: CDouble
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double logic_and__5(std::string ** err_msg, double* x0, double* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    double logic_and__5(std::string ** err_msg, double* x0, double* x1);
double logic_and__5(std::string ** err_msg, double* x0, double* x1){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

        double ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_and" ===============
// cppName: "casadi::logic_and"
// cWrapperName: "logic_and__6"
// protoArgs: "(std::string ** err_msg, int* x0, int* x1)"
// params: [Ref (Const CInt),Ref (Const CInt)]
// retType: CInt
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int logic_and__6(std::string ** err_msg, int* x0, int* x1)"
// call: "casadi::logic_and(x0_, x1_)"
extern "C"
    int logic_and__6(std::string ** err_msg, int* x0, int* x1);
int logic_and__6(std::string ** err_msg, int* x0, int* x1){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

        int ret = casadi::logic_and(x0_, x1_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* logic_not__0(std::string ** err_msg, casadi::SXElement* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    casadi::SXElement* logic_not__0(std::string ** err_msg, casadi::SXElement* x0);
casadi::SXElement* logic_not__0(std::string ** err_msg, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = casadi::logic_not(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* logic_not__1(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    casadi::MX* logic_not__1(std::string ** err_msg, casadi::MX* x0);
casadi::MX* logic_not__1(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::logic_not(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* logic_not__2(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    casadi::SX* logic_not__2(std::string ** err_msg, casadi::SX* x0);
casadi::SX* logic_not__2(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::logic_not(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* logic_not__3(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    casadi::DMatrix* logic_not__3(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* logic_not__3(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::logic_not(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* logic_not__4(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    casadi::IMatrix* logic_not__4(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* logic_not__4(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::logic_not(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__5"
// protoArgs: "(std::string ** err_msg, double* x0)"
// params: [Ref (Const CDouble)]
// retType: CDouble
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double logic_not__5(std::string ** err_msg, double* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    double logic_not__5(std::string ** err_msg, double* x0);
double logic_not__5(std::string ** err_msg, double* x0){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);

        double ret = casadi::logic_not(x0_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_not" ===============
// cppName: "casadi::logic_not"
// cWrapperName: "logic_not__6"
// protoArgs: "(std::string ** err_msg, int* x0)"
// params: [Ref (Const CInt)]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int logic_not__6(std::string ** err_msg, int* x0)"
// call: "casadi::logic_not(x0_)"
extern "C"
    int logic_not__6(std::string ** err_msg, int* x0);
int logic_not__6(std::string ** err_msg, int* x0){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);

        int ret = casadi::logic_not(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* logic_or__0(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    casadi::SXElement* logic_or__0(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1);
casadi::SXElement* logic_or__0(std::string ** err_msg, casadi::SXElement* x0, casadi::SXElement* x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

        casadi::SXElement ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* logic_or__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    casadi::MX* logic_or__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* logic_or__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* logic_or__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    casadi::SX* logic_or__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* logic_or__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* logic_or__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    casadi::DMatrix* logic_or__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* logic_or__3(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* logic_or__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    casadi::IMatrix* logic_or__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* logic_or__4(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__5"
// protoArgs: "(std::string ** err_msg, double* x0, double* x1)"
// params: [Ref (Const CDouble),Ref (Const CDouble)]
// retType: CDouble
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double logic_or__5(std::string ** err_msg, double* x0, double* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    double logic_or__5(std::string ** err_msg, double* x0, double* x1);
double logic_or__5(std::string ** err_msg, double* x0, double* x1){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

        double ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::logic_or" ===============
// cppName: "casadi::logic_or"
// cWrapperName: "logic_or__6"
// protoArgs: "(std::string ** err_msg, int* x0, int* x1)"
// params: [Ref (Const CInt),Ref (Const CInt)]
// retType: CInt
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int logic_or__6(std::string ** err_msg, int* x0, int* x1)"
// call: "casadi::logic_or(x0_, x1_)"
extern "C"
    int logic_or__6(std::string ** err_msg, int* x0, int* x1);
int logic_or__6(std::string ** err_msg, int* x0, int* x1){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

        int ret = casadi::logic_or(x0_, x1_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lookupvector" ===============
// cppName: "casadi::lookupvector"
// cWrapperName: "lookupvector"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, int x1)"
// params: [Ref (Const (StdVec CInt)),CInt]
// retType: StdVec CInt
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* lookupvector(std::string ** err_msg, std::vector< int >* x0, int x1)"
// call: "casadi::lookupvector(x0_, x1_)"
extern "C"
    std::vector< int >* lookupvector(std::string ** err_msg, std::vector< int >* x0, int x1);
std::vector< int >* lookupvector(std::string ** err_msg, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< int > ret = casadi::lookupvector(x0_, x1_);
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::lpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* lpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::lpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* lpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::lpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* lpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* lpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* lpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* lpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* lpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::lpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* lpIn__7(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::lpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* lpIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::lpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* lpIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* lpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* lpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* lpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* lpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* lpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::lpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* lpIn__14(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::lpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* lpIn__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::lpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* lpIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* lpIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* lpIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* lpIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpIn" ===============
// cppName: "casadi::lpIn"
// cWrapperName: "lpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* lpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* lpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::lpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::lpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* lpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::lpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::lpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* lpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::lpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::lpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* lpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::lpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::lpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* lpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::lpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::lpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* lpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::lpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::lpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* lpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* lpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::lpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::lpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* lpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* lpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::lpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::lpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* lpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* lpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::lpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::lpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* lpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* lpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::lpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* lpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::lpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* lpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* lpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::lpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::lpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* lpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* lpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::lpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::lpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* lpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* lpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::lpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::lpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* lpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* lpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::lpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::lpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* lpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* lpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::lpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpOut" ===============
// cppName: "casadi::lpOut"
// cWrapperName: "lpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* lpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::lpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* lpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* lpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::lpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpStruct" ===============
// cppName: "casadi::lpStruct"
// cWrapperName: "lpStruct__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::lpStruct(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* lpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::lpStruct(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::lpStruct" ===============
// cppName: "casadi::lpStruct"
// cWrapperName: "lpStruct__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* lpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::lpStruct(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* lpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* lpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::lpStruct(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::matrix_expand" ===============
// cppName: "casadi::matrix_expand"
// cWrapperName: "matrix_expand__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* matrix_expand__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::matrix_expand(x0_)"
extern "C"
    std::vector< casadi::MX* >* matrix_expand__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* matrix_expand__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::matrix_expand(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::matrix_expand" ===============
// cppName: "casadi::matrix_expand"
// cWrapperName: "matrix_expand__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* matrix_expand__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
// call: "casadi::matrix_expand(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* matrix_expand__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1);
std::vector< casadi::MX* >* matrix_expand__1(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::matrix_expand(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::matrix_expand" ===============
// cppName: "casadi::matrix_expand"
// cWrapperName: "matrix_expand__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* matrix_expand__2(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::matrix_expand(x0_)"
extern "C"
    casadi::MX* matrix_expand__2(std::string ** err_msg, casadi::MX* x0);
casadi::MX* matrix_expand__2(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::matrix_expand(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::matrix_expand" ===============
// cppName: "casadi::matrix_expand"
// cWrapperName: "matrix_expand__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* matrix_expand__3(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1)"
// call: "casadi::matrix_expand(x0_, x1_)"
extern "C"
    casadi::MX* matrix_expand__3(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1);
casadi::MX* matrix_expand__3(std::string ** err_msg, casadi::MX* x0, std::vector< casadi::MX* >* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);

        casadi::MX ret = casadi::matrix_expand(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* mayerIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::mayerIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* mayerIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* mayerIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::mayerIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* mayerIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::mayerIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* mayerIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* mayerIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::mayerIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* mayerIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::mayerIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* mayerIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* mayerIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::mayerIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* mayerIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::mayerIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* mayerIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* mayerIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::mayerIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* mayerIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::mayerIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* mayerIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* mayerIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::mayerIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* mayerIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::mayerIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* mayerIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* mayerIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::mayerIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* mayerIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::mayerIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* mayerIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* mayerIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::mayerIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* mayerIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::mayerIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* mayerIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* mayerIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::mayerIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mayerIn" ===============
// cppName: "casadi::mayerIn"
// cWrapperName: "mayerIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* mayerIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::mayerIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* mayerIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* mayerIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::mayerIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mtaylor" ===============
// cppName: "casadi::mtaylor"
// cWrapperName: "mtaylor__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3, std::vector< int >* x4)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,Ref (Const (StdVec CInt))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* mtaylor__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3, std::vector< int >* x4)"
// call: "casadi::mtaylor(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    casadi::SX* mtaylor__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3, std::vector< int >* x4);
casadi::SX* mtaylor__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3, std::vector< int >* x4){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);

        casadi::SX ret = casadi::mtaylor(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mtaylor" ===============
// cppName: "casadi::mtaylor"
// cWrapperName: "mtaylor__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* mtaylor__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::mtaylor(x0_, x1_, x2_)"
extern "C"
    casadi::SX* mtaylor__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* mtaylor__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::mtaylor(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mtaylor" ===============
// cppName: "casadi::mtaylor"
// cWrapperName: "mtaylor__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* mtaylor__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3)"
// call: "casadi::mtaylor(x0_, x1_, x2_, x3_)"
extern "C"
    casadi::SX* mtaylor__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3);
casadi::SX* mtaylor__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        casadi::SX ret = casadi::mtaylor(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* mul__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::mul(x0_)"
extern "C"
    casadi::MX* mul__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* mul__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::mul(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* mul__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::mul(x0_, x1_)"
extern "C"
    casadi::MX* mul__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* mul__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::mul(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::Sparsity* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* mul__2(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::Sparsity* x2)"
// call: "casadi::mul(x0_, x1_, x2_)"
extern "C"
    casadi::MX* mul__2(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::Sparsity* x2);
casadi::MX* mul__2(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::Sparsity* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
        casadi::Sparsity x2_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x2);

        casadi::MX ret = casadi::mul(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* mul__3(std::string ** err_msg, casadi::Sparsity* x0, casadi::Sparsity* x1)"
// call: "casadi::mul(x0_, x1_)"
extern "C"
    casadi::Sparsity* mul__3(std::string ** err_msg, casadi::Sparsity* x0, casadi::Sparsity* x1);
casadi::Sparsity* mul__3(std::string ** err_msg, casadi::Sparsity* x0, casadi::Sparsity* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::Sparsity ret = casadi::mul(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* mul__4(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::mul(x0_)"
extern "C"
    casadi::SX* mul__4(std::string ** err_msg, std::vector< casadi::SX* >* x0);
casadi::SX* mul__4(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SX ret = casadi::mul(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* mul__5(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::mul(x0_, x1_)"
extern "C"
    casadi::SX* mul__5(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* mul__5(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::mul(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__6"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::Sparsity* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* mul__6(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::Sparsity* x2)"
// call: "casadi::mul(x0_, x1_, x2_)"
extern "C"
    casadi::SX* mul__6(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::Sparsity* x2);
casadi::SX* mul__6(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::Sparsity* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::Sparsity x2_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x2);

        casadi::SX ret = casadi::mul(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* mul__7(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// call: "casadi::mul(x0_)"
extern "C"
    casadi::DMatrix* mul__7(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0);
casadi::DMatrix* mul__7(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::mul(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__8"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* mul__8(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::mul(x0_, x1_)"
extern "C"
    casadi::DMatrix* mul__8(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* mul__8(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::mul(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__9"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::Sparsity* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* mul__9(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::Sparsity* x2)"
// call: "casadi::mul(x0_, x1_, x2_)"
extern "C"
    casadi::DMatrix* mul__9(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::Sparsity* x2);
casadi::DMatrix* mul__9(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::Sparsity* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);
        casadi::Sparsity x2_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x2);

        casadi::DMatrix ret = casadi::mul(x0_, x1_, x2_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* mul__10(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// call: "casadi::mul(x0_)"
extern "C"
    casadi::IMatrix* mul__10(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0);
casadi::IMatrix* mul__10(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0){
    try {
        std::vector< casadi::IMatrix > x0_ = Marshaling<std::vector< casadi::IMatrix >,std::vector< casadi::IMatrix* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::mul(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__11"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* mul__11(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::mul(x0_, x1_)"
extern "C"
    casadi::IMatrix* mul__11(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* mul__11(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::mul(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::mul" ===============
// cppName: "casadi::mul"
// cWrapperName: "mul__12"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Sparsity* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* mul__12(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Sparsity* x2)"
// call: "casadi::mul(x0_, x1_, x2_)"
extern "C"
    casadi::IMatrix* mul__12(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Sparsity* x2);
casadi::IMatrix* mul__12(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Sparsity* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::Sparsity x2_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x2);

        casadi::IMatrix ret = casadi::mul(x0_, x1_, x2_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::nlpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* nlpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::nlpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::nlpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* nlpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::nlpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* nlpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::nlpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::nlpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* nlpIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* nlpIn__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::nlpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::nlpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* nlpIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* nlpIn__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::nlpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* nlpIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* nlpIn__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::nlpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::nlpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* nlpIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* nlpIn__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::nlpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::nlpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* nlpIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* nlpIn__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::nlpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpIn" ===============
// cppName: "casadi::nlpIn"
// cWrapperName: "nlpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* nlpIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* nlpIn__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::nlpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::nlpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* nlpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::nlpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::nlpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* nlpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::nlpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* nlpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::nlpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::nlpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* nlpOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* nlpOut__3(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::nlpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::nlpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* nlpOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* nlpOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::nlpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* nlpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* nlpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::nlpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpOut__6(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::nlpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* nlpOut__6(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* nlpOut__6(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::nlpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpOut__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::nlpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* nlpOut__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* nlpOut__7(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::nlpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpOut" ===============
// cppName: "casadi::nlpOut"
// cWrapperName: "nlpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* nlpOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* nlpOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::nlpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::nlpSolverIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* nlpSolverIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::nlpSolverIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* nlpSolverIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* nlpSolverIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* nlpSolverIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* nlpSolverIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* nlpSolverIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* nlpSolverIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* nlpSolverIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* nlpSolverIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::nlpSolverIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* nlpSolverIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::nlpSolverIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* nlpSolverIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* nlpSolverIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* nlpSolverIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* nlpSolverIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* nlpSolverIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* nlpSolverIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* nlpSolverIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* nlpSolverIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::nlpSolverIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* nlpSolverIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::nlpSolverIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* nlpSolverIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* nlpSolverIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* nlpSolverIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* nlpSolverIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* nlpSolverIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* nlpSolverIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* nlpSolverIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverIn" ===============
// cppName: "casadi::nlpSolverIn"
// cWrapperName: "nlpSolverIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* nlpSolverIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::nlpSolverIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::nlpSolverOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* nlpSolverOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::nlpSolverOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* nlpSolverOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* nlpSolverOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* nlpSolverOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* nlpSolverOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* nlpSolverOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* nlpSolverOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* nlpSolverOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* nlpSolverOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::nlpSolverOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* nlpSolverOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::nlpSolverOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* nlpSolverOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* nlpSolverOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* nlpSolverOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* nlpSolverOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* nlpSolverOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* nlpSolverOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* nlpSolverOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* nlpSolverOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::nlpSolverOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* nlpSolverOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::nlpSolverOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* nlpSolverOut__15(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* nlpSolverOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* nlpSolverOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* nlpSolverOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* nlpSolverOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nlpSolverOut" ===============
// cppName: "casadi::nlpSolverOut"
// cWrapperName: "nlpSolverOut__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* nlpSolverOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* nlpSolverOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* nlpSolverOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::nlpSolverOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_1" ===============
// cppName: "casadi::norm_1"
// cWrapperName: "norm_1__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* norm_1__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::norm_1(x0_)"
extern "C"
    casadi::MX* norm_1__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* norm_1__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::norm_1(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_1" ===============
// cppName: "casadi::norm_1"
// cWrapperName: "norm_1__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* norm_1__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::norm_1(x0_)"
extern "C"
    casadi::SX* norm_1__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* norm_1__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::norm_1(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_1" ===============
// cppName: "casadi::norm_1"
// cWrapperName: "norm_1__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* norm_1__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::norm_1(x0_)"
extern "C"
    casadi::DMatrix* norm_1__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* norm_1__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::norm_1(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_1" ===============
// cppName: "casadi::norm_1"
// cWrapperName: "norm_1__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* norm_1__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::norm_1(x0_)"
extern "C"
    casadi::IMatrix* norm_1__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* norm_1__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::norm_1(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_2" ===============
// cppName: "casadi::norm_2"
// cWrapperName: "norm_2__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* norm_2__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::norm_2(x0_)"
extern "C"
    casadi::MX* norm_2__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* norm_2__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::norm_2(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_2" ===============
// cppName: "casadi::norm_2"
// cWrapperName: "norm_2__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* norm_2__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::norm_2(x0_)"
extern "C"
    casadi::SX* norm_2__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* norm_2__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::norm_2(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_2" ===============
// cppName: "casadi::norm_2"
// cWrapperName: "norm_2__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* norm_2__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::norm_2(x0_)"
extern "C"
    casadi::DMatrix* norm_2__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* norm_2__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::norm_2(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_2" ===============
// cppName: "casadi::norm_2"
// cWrapperName: "norm_2__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* norm_2__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::norm_2(x0_)"
extern "C"
    casadi::IMatrix* norm_2__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* norm_2__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::norm_2(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_F" ===============
// cppName: "casadi::norm_F"
// cWrapperName: "norm_F__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* norm_F__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::norm_F(x0_)"
extern "C"
    casadi::MX* norm_F__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* norm_F__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::norm_F(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_F" ===============
// cppName: "casadi::norm_F"
// cWrapperName: "norm_F__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* norm_F__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::norm_F(x0_)"
extern "C"
    casadi::SX* norm_F__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* norm_F__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::norm_F(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_F" ===============
// cppName: "casadi::norm_F"
// cWrapperName: "norm_F__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* norm_F__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::norm_F(x0_)"
extern "C"
    casadi::DMatrix* norm_F__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* norm_F__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::norm_F(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_F" ===============
// cppName: "casadi::norm_F"
// cWrapperName: "norm_F__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* norm_F__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::norm_F(x0_)"
extern "C"
    casadi::IMatrix* norm_F__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* norm_F__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::norm_F(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_inf" ===============
// cppName: "casadi::norm_inf"
// cWrapperName: "norm_inf__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* norm_inf__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::norm_inf(x0_)"
extern "C"
    casadi::MX* norm_inf__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* norm_inf__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::norm_inf(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_inf" ===============
// cppName: "casadi::norm_inf"
// cWrapperName: "norm_inf__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* norm_inf__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::norm_inf(x0_)"
extern "C"
    casadi::SX* norm_inf__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* norm_inf__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::norm_inf(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_inf" ===============
// cppName: "casadi::norm_inf"
// cWrapperName: "norm_inf__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* norm_inf__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::norm_inf(x0_)"
extern "C"
    casadi::DMatrix* norm_inf__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* norm_inf__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::norm_inf(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::norm_inf" ===============
// cppName: "casadi::norm_inf"
// cWrapperName: "norm_inf__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* norm_inf__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::norm_inf(x0_)"
extern "C"
    casadi::IMatrix* norm_inf__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* norm_inf__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::norm_inf(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nullspace" ===============
// cppName: "casadi::nullspace"
// cWrapperName: "nullspace__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* nullspace__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::nullspace(x0_)"
extern "C"
    casadi::MX* nullspace__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* nullspace__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::nullspace(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nullspace" ===============
// cppName: "casadi::nullspace"
// cWrapperName: "nullspace__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* nullspace__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::nullspace(x0_)"
extern "C"
    casadi::SX* nullspace__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* nullspace__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::nullspace(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nullspace" ===============
// cppName: "casadi::nullspace"
// cWrapperName: "nullspace__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* nullspace__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::nullspace(x0_)"
extern "C"
    casadi::DMatrix* nullspace__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* nullspace__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::nullspace(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::nullspace" ===============
// cppName: "casadi::nullspace"
// cWrapperName: "nullspace__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* nullspace__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::nullspace(x0_)"
extern "C"
    casadi::IMatrix* nullspace__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* nullspace__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::nullspace(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::ocpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* ocpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::ocpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* ocpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::ocpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* ocpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* ocpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* ocpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* ocpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* ocpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* ocpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* ocpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* ocpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::Sparsity* >* ocpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::Sparsity* >* ocpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::Sparsity* >* ocpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpIn__13(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpIn__13(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13);
std::vector< casadi::Sparsity* >* ocpIn__13(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);
        std::string x13_ = Marshaling<std::string,std::string*>::marshal(x13);

        std::vector< casadi::Sparsity > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::ocpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* ocpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::ocpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* ocpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::ocpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* ocpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* ocpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* ocpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* ocpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* ocpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* ocpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* ocpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* ocpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::MX* >* ocpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::MX* >* ocpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__26(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__26(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::MX* >* ocpIn__26(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpIn__27(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
extern "C"
    std::vector< casadi::MX* >* ocpIn__27(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13);
std::vector< casadi::MX* >* ocpIn__27(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);
        std::string x13_ = Marshaling<std::string,std::string*>::marshal(x13);

        std::vector< casadi::MX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::ocpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* ocpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::ocpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* ocpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__30"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::ocpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* ocpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__31"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* ocpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__32"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* ocpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__33"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* ocpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__34"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* ocpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__35"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* ocpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__36"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* ocpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__37"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* ocpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__38"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::SX* >* ocpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__39"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__39(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__39(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::SX* >* ocpIn__39(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__40"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__40(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__40(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::SX* >* ocpIn__40(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpIn" ===============
// cppName: "casadi::ocpIn"
// cWrapperName: "ocpIn__41"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpIn__41(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13)"
// call: "casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
extern "C"
    std::vector< casadi::SX* >* ocpIn__41(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13);
std::vector< casadi::SX* >* ocpIn__41(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12, std::string* x13){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);
        std::string x13_ = Marshaling<std::string,std::string*>::marshal(x13);

        std::vector< casadi::SX > ret = casadi::ocpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::ocpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* ocpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::ocpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::ocpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* ocpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::ocpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::ocpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* ocpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::ocpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::ocpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* ocpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::ocpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* ocpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::ocpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* ocpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* ocpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::ocpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::ocpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* ocpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* ocpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::ocpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::ocpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* ocpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* ocpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::ocpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::ocpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* ocpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* ocpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::ocpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::ocpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* ocpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* ocpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::ocpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* ocpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::ocpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* ocpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* ocpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::ocpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::ocpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* ocpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* ocpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::ocpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::ocpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* ocpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* ocpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::ocpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::ocpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* ocpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* ocpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::ocpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::ocpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* ocpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* ocpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::ocpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ocpOut" ===============
// cppName: "casadi::ocpOut"
// cWrapperName: "ocpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* ocpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::ocpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* ocpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* ocpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::ocpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::outer_prod" ===============
// cppName: "casadi::outer_prod"
// cWrapperName: "outer_prod__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* outer_prod__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::outer_prod(x0_, x1_)"
extern "C"
    casadi::MX* outer_prod__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* outer_prod__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::outer_prod(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::outer_prod" ===============
// cppName: "casadi::outer_prod"
// cWrapperName: "outer_prod__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* outer_prod__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::outer_prod(x0_, x1_)"
extern "C"
    casadi::SX* outer_prod__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* outer_prod__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::outer_prod(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::outer_prod" ===============
// cppName: "casadi::outer_prod"
// cWrapperName: "outer_prod__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* outer_prod__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::outer_prod(x0_, x1_)"
extern "C"
    casadi::DMatrix* outer_prod__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* outer_prod__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::outer_prod(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::outer_prod" ===============
// cppName: "casadi::outer_prod"
// cWrapperName: "outer_prod__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* outer_prod__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::outer_prod(x0_, x1_)"
extern "C"
    casadi::IMatrix* outer_prod__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* outer_prod__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::outer_prod(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::pinv" ===============
// cppName: "casadi::pinv"
// cWrapperName: "pinv__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* pinv__0(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::pinv(x0_)"
extern "C"
    casadi::SX* pinv__0(std::string ** err_msg, casadi::SX* x0);
casadi::SX* pinv__0(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::pinv(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::pinv" ===============
// cppName: "casadi::pinv"
// cWrapperName: "pinv__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* pinv__1(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::pinv(x0_)"
extern "C"
    casadi::DMatrix* pinv__1(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* pinv__1(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::pinv(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::pinv" ===============
// cppName: "casadi::pinv"
// cWrapperName: "pinv__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* pinv__2(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::pinv(x0_)"
extern "C"
    casadi::IMatrix* pinv__2(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* pinv__2(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::pinv(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::poly_coeff" ===============
// cppName: "casadi::poly_coeff"
// cWrapperName: "poly_coeff"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* poly_coeff(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::poly_coeff(x0_, x1_)"
extern "C"
    casadi::SX* poly_coeff(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* poly_coeff(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::poly_coeff(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::poly_roots" ===============
// cppName: "casadi::poly_roots"
// cWrapperName: "poly_roots"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* poly_roots(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::poly_roots(x0_)"
extern "C"
    casadi::SX* poly_roots(std::string ** err_msg, casadi::SX* x0);
casadi::SX* poly_roots(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::poly_roots(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::polyval" ===============
// cppName: "casadi::polyval"
// cWrapperName: "polyval__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* polyval__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::polyval(x0_, x1_)"
extern "C"
    casadi::MX* polyval__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* polyval__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::polyval(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::polyval" ===============
// cppName: "casadi::polyval"
// cWrapperName: "polyval__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* polyval__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::polyval(x0_, x1_)"
extern "C"
    casadi::SX* polyval__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* polyval__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::polyval(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::polyval" ===============
// cppName: "casadi::polyval"
// cWrapperName: "polyval__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* polyval__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::polyval(x0_, x1_)"
extern "C"
    casadi::DMatrix* polyval__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* polyval__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::polyval(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::polyval" ===============
// cppName: "casadi::polyval"
// cWrapperName: "polyval__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* polyval__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::polyval(x0_, x1_)"
extern "C"
    casadi::IMatrix* polyval__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* polyval__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::polyval(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::printCompact" ===============
// cppName: "casadi::printCompact"
// cWrapperName: "printCompact__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: CVoid
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void printCompact__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::printCompact(x0_)"
extern "C"
    void printCompact__0(std::string ** err_msg, casadi::MX* x0);
void printCompact__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    casadi::printCompact(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::printCompact" ===============
// cppName: "casadi::printCompact"
// cWrapperName: "printCompact__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CVoid
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void printCompact__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::printCompact(x0_)"
extern "C"
    void printCompact__1(std::string ** err_msg, casadi::SX* x0);
void printCompact__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    casadi::printCompact(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::project" ===============
// cppName: "casadi::project"
// cWrapperName: "project__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* project__0(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1)"
// call: "casadi::project(x0_, x1_)"
extern "C"
    casadi::SX* project__0(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1);
casadi::SX* project__0(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::SX ret = casadi::project(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::project" ===============
// cppName: "casadi::project"
// cWrapperName: "project__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* project__1(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// call: "casadi::project(x0_, x1_)"
extern "C"
    casadi::DMatrix* project__1(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1);
casadi::DMatrix* project__1(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::DMatrix ret = casadi::project(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::project" ===============
// cppName: "casadi::project"
// cWrapperName: "project__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* project__2(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// call: "casadi::project(x0_, x1_)"
extern "C"
    casadi::IMatrix* project__2(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1);
casadi::IMatrix* project__2(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::IMatrix ret = casadi::project(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::pw_const" ===============
// cppName: "casadi::pw_const"
// cWrapperName: "pw_const"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* pw_const(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::pw_const(x0_, x1_, x2_)"
extern "C"
    casadi::SX* pw_const(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* pw_const(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::pw_const(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::pw_lin" ===============
// cppName: "casadi::pw_lin"
// cWrapperName: "pw_lin"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* pw_lin(std::string ** err_msg, casadi::SXElement* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::pw_lin(x0_, x1_, x2_)"
extern "C"
    casadi::SX* pw_lin(std::string ** err_msg, casadi::SXElement* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* pw_lin(std::string ** err_msg, casadi::SXElement* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::pw_lin(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::qcqpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* qcqpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::qcqpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* qcqpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* qcqpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* qcqpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* qcqpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* qcqpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* qcqpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* qcqpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* qcqpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* qcqpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::Sparsity* >* qcqpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::Sparsity* >* qcqpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::Sparsity* >* qcqpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::Sparsity > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::qcqpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* qcqpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::qcqpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* qcqpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* qcqpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* qcqpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* qcqpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* qcqpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* qcqpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* qcqpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* qcqpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* qcqpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::MX* >* qcqpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::MX* >* qcqpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::MX* >* qcqpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::MX* >* qcqpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::MX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::qcqpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* qcqpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::qcqpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* qcqpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* qcqpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* qcqpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__30"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* qcqpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__31"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* qcqpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__32"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* qcqpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__33"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* qcqpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__34"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* qcqpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__35"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* qcqpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__36"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::SX* >* qcqpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__37"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::SX* >* qcqpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpIn" ===============
// cppName: "casadi::qcqpIn"
// cWrapperName: "qcqpIn__38"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::SX* >* qcqpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::SX* >* qcqpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::SX > ret = casadi::qcqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::qcqpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* qcqpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::qcqpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::qcqpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* qcqpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::qcqpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* qcqpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::qcqpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* qcqpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::qcqpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qcqpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* qcqpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::qcqpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::qcqpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* qcqpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* qcqpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::qcqpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::qcqpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* qcqpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* qcqpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::qcqpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* qcqpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* qcqpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::qcqpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* qcqpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* qcqpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::qcqpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qcqpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qcqpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* qcqpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* qcqpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::qcqpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::qcqpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* qcqpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* qcqpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::qcqpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::qcqpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* qcqpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* qcqpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::qcqpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* qcqpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* qcqpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::qcqpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* qcqpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* qcqpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::qcqpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpOut" ===============
// cppName: "casadi::qcqpOut"
// cWrapperName: "qcqpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qcqpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qcqpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* qcqpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* qcqpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::qcqpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpStruct" ===============
// cppName: "casadi::qcqpStruct"
// cWrapperName: "qcqpStruct__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::qcqpStruct(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* qcqpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::qcqpStruct(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpStruct" ===============
// cppName: "casadi::qcqpStruct"
// cWrapperName: "qcqpStruct__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::qcqpStruct(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* qcqpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::qcqpStruct(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpStruct" ===============
// cppName: "casadi::qcqpStruct"
// cWrapperName: "qcqpStruct__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qcqpStruct(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* qcqpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::qcqpStruct(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qcqpStruct" ===============
// cppName: "casadi::qcqpStruct"
// cWrapperName: "qcqpStruct__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qcqpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qcqpStruct(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* qcqpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* qcqpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::qcqpStruct(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::qpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* qpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::qpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* qpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* qpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* qpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* qpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* qpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* qpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* qpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* qpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* qpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::qpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* qpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::qpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* qpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* qpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* qpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* qpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* qpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* qpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* qpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* qpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* qpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* qpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::qpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* qpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::qpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* qpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* qpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* qpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* qpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* qpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* qpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* qpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* qpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpIn" ===============
// cppName: "casadi::qpIn"
// cWrapperName: "qpIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* qpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* qpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::qpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::qpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* qpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::qpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::qpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* qpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::qpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* qpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::qpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* qpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::qpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* qpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::qpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::qpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* qpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* qpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::qpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::qpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* qpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* qpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::qpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* qpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* qpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::qpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* qpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* qpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::qpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* qpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* qpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* qpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::qpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::qpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* qpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* qpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::qpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::qpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* qpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* qpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::qpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* qpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* qpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::qpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::qpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* qpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* qpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::qpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpOut" ===============
// cppName: "casadi::qpOut"
// cWrapperName: "qpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* qpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::qpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* qpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* qpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::qpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpStruct" ===============
// cppName: "casadi::qpStruct"
// cWrapperName: "qpStruct__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::qpStruct(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* qpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::qpStruct(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpStruct" ===============
// cppName: "casadi::qpStruct"
// cWrapperName: "qpStruct__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::qpStruct(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* qpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::qpStruct(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::qpStruct" ===============
// cppName: "casadi::qpStruct"
// cWrapperName: "qpStruct__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* qpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::qpStruct(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* qpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* qpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::qpStruct(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::ramp" ===============
// cppName: "casadi::ramp"
// cWrapperName: "ramp"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* ramp(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::ramp(x0_)"
extern "C"
    casadi::SX* ramp(std::string ** err_msg, casadi::SX* x0);
casadi::SX* ramp(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::ramp(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rank" ===============
// cppName: "casadi::rank"
// cWrapperName: "rank"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int rank(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::rank(x0_)"
extern "C"
    int rank(std::string ** err_msg, casadi::Sparsity* x0);
int rank(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        int ret = casadi::rank(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::rdaeIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* rdaeIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::rdaeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* rdaeIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::rdaeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* rdaeIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* rdaeIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* rdaeIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* rdaeIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* rdaeIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* rdaeIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::rdaeIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* rdaeIn__8(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::rdaeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* rdaeIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::rdaeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* rdaeIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* rdaeIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* rdaeIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* rdaeIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* rdaeIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* rdaeIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* rdaeIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::rdaeIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* rdaeIn__16(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::rdaeIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* rdaeIn__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::rdaeIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* rdaeIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* rdaeIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* rdaeIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* rdaeIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* rdaeIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeIn" ===============
// cppName: "casadi::rdaeIn"
// cWrapperName: "rdaeIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* rdaeIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* rdaeIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::rdaeIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::rdaeOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* rdaeOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::rdaeOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::rdaeOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* rdaeOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::rdaeOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::rdaeOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* rdaeOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::rdaeOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* rdaeOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::rdaeOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* rdaeOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* rdaeOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::rdaeOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::rdaeOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* rdaeOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* rdaeOut__4(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::rdaeOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::rdaeOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* rdaeOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* rdaeOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::rdaeOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::rdaeOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* rdaeOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* rdaeOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::rdaeOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* rdaeOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::rdaeOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* rdaeOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* rdaeOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::rdaeOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::rdaeOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* rdaeOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* rdaeOut__8(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::rdaeOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::rdaeOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* rdaeOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* rdaeOut__9(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::rdaeOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::rdaeOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* rdaeOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* rdaeOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::rdaeOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rdaeOut" ===============
// cppName: "casadi::rdaeOut"
// cWrapperName: "rdaeOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* rdaeOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::rdaeOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* rdaeOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* rdaeOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::rdaeOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::rectangle" ===============
// cppName: "casadi::rectangle"
// cWrapperName: "rectangle"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* rectangle(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::rectangle(x0_)"
extern "C"
    casadi::SX* rectangle(std::string ** err_msg, casadi::SX* x0);
casadi::SX* rectangle(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::rectangle(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::repmat" ===============
// cppName: "casadi::repmat"
// cWrapperName: "repmat__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* repmat__0(std::string ** err_msg, casadi::MX* x0, int x1, int x2)"
// call: "casadi::repmat(x0_, x1_, x2_)"
extern "C"
    casadi::MX* repmat__0(std::string ** err_msg, casadi::MX* x0, int x1, int x2);
casadi::MX* repmat__0(std::string ** err_msg, casadi::MX* x0, int x1, int x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::MX ret = casadi::repmat(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::repmat" ===============
// cppName: "casadi::repmat"
// cWrapperName: "repmat__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* repmat__1(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// call: "casadi::repmat(x0_, x1_, x2_)"
extern "C"
    casadi::SX* repmat__1(std::string ** err_msg, casadi::SX* x0, int x1, int x2);
casadi::SX* repmat__1(std::string ** err_msg, casadi::SX* x0, int x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::repmat(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::repmat" ===============
// cppName: "casadi::repmat"
// cWrapperName: "repmat__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* repmat__2(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// call: "casadi::repmat(x0_, x1_, x2_)"
extern "C"
    casadi::DMatrix* repmat__2(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2);
casadi::DMatrix* repmat__2(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::DMatrix ret = casadi::repmat(x0_, x1_, x2_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::repmat" ===============
// cppName: "casadi::repmat"
// cWrapperName: "repmat__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* repmat__3(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// call: "casadi::repmat(x0_, x1_, x2_)"
extern "C"
    casadi::IMatrix* repmat__3(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2);
casadi::IMatrix* repmat__3(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::IMatrix ret = casadi::repmat(x0_, x1_, x2_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* reshape__0(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1)"
// call: "casadi::reshape(x0_, x1_)"
extern "C"
    casadi::MX* reshape__0(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1);
casadi::MX* reshape__0(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::MX ret = casadi::reshape(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* reshape__1(std::string ** err_msg, casadi::Sparsity* x0, int x1, int x2)"
// call: "casadi::reshape(x0_, x1_, x2_)"
extern "C"
    casadi::Sparsity* reshape__1(std::string ** err_msg, casadi::Sparsity* x0, int x1, int x2);
casadi::Sparsity* reshape__1(std::string ** err_msg, casadi::Sparsity* x0, int x1, int x2){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::Sparsity ret = casadi::reshape(x0_, x1_, x2_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* reshape__2(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1)"
// call: "casadi::reshape(x0_, x1_)"
extern "C"
    casadi::SX* reshape__2(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1);
casadi::SX* reshape__2(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::SX ret = casadi::reshape(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* reshape__3(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// call: "casadi::reshape(x0_, x1_, x2_)"
extern "C"
    casadi::SX* reshape__3(std::string ** err_msg, casadi::SX* x0, int x1, int x2);
casadi::SX* reshape__3(std::string ** err_msg, casadi::SX* x0, int x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::reshape(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* reshape__4(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// call: "casadi::reshape(x0_, x1_)"
extern "C"
    casadi::DMatrix* reshape__4(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1);
casadi::DMatrix* reshape__4(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::DMatrix ret = casadi::reshape(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* reshape__5(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// call: "casadi::reshape(x0_, x1_, x2_)"
extern "C"
    casadi::DMatrix* reshape__5(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2);
casadi::DMatrix* reshape__5(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::DMatrix ret = casadi::reshape(x0_, x1_, x2_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__6"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* reshape__6(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// call: "casadi::reshape(x0_, x1_)"
extern "C"
    casadi::IMatrix* reshape__6(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1);
casadi::IMatrix* reshape__6(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::IMatrix ret = casadi::reshape(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::reshape" ===============
// cppName: "casadi::reshape"
// cWrapperName: "reshape__7"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* reshape__7(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// call: "casadi::reshape(x0_, x1_, x2_)"
extern "C"
    casadi::IMatrix* reshape__7(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2);
casadi::IMatrix* reshape__7(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::IMatrix ret = casadi::reshape(x0_, x1_, x2_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::sdpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* sdpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::sdpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* sdpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* sdpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* sdpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* sdpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* sdpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* sdpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* sdpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* sdpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::sdpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* sdpIn__9(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::sdpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* sdpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* sdpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* sdpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* sdpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* sdpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* sdpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* sdpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* sdpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* sdpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::sdpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* sdpIn__18(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::sdpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* sdpIn__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* sdpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* sdpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* sdpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* sdpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* sdpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* sdpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpIn" ===============
// cppName: "casadi::sdpIn"
// cWrapperName: "sdpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* sdpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* sdpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::sdpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::sdpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* sdpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::sdpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* sdpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* sdpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* sdpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* sdpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* sdpOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* sdpOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpOut__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpOut__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* sdpOut__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::sdpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* sdpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::sdpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* sdpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* sdpOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* sdpOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* sdpOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* sdpOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* sdpOut__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdpOut__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* sdpOut__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* sdpOut__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::sdpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* sdpOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::sdpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* sdpOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* sdpOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* sdpOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* sdpOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* sdpOut__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* sdpOut__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpOut" ===============
// cppName: "casadi::sdpOut"
// cWrapperName: "sdpOut__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdpOut__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* sdpOut__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* sdpOut__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::sdpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpStruct" ===============
// cppName: "casadi::sdpStruct"
// cWrapperName: "sdpStruct__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::sdpStruct(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* sdpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::sdpStruct(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpStruct" ===============
// cppName: "casadi::sdpStruct"
// cWrapperName: "sdpStruct__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::sdpStruct(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* sdpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::sdpStruct(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpStruct" ===============
// cppName: "casadi::sdpStruct"
// cWrapperName: "sdpStruct__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdpStruct(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* sdpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::sdpStruct(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdpStruct" ===============
// cppName: "casadi::sdpStruct"
// cWrapperName: "sdpStruct__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdpStruct(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* sdpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::sdpStruct(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::sdqpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* sdqpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::sdqpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* sdqpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* sdqpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* sdqpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* sdqpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* sdqpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* sdqpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* sdqpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* sdqpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* sdqpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::sdqpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* sdqpIn__10(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::sdqpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* sdqpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* sdqpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* sdqpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* sdqpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* sdqpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* sdqpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* sdqpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* sdqpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* sdqpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* sdqpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::sdqpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* sdqpIn__20(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::sdqpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* sdqpIn__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* sdqpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* sdqpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* sdqpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* sdqpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* sdqpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* sdqpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* sdqpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpIn" ===============
// cppName: "casadi::sdqpIn"
// cWrapperName: "sdqpIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* sdqpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* sdqpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::sdqpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::sdqpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* sdqpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::sdqpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* sdqpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* sdqpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* sdqpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* sdqpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* sdqpOut__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* sdqpOut__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpOut__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpOut__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* sdqpOut__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::sdqpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* sdqpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::sdqpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* sdqpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* sdqpOut__10(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* sdqpOut__11(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* sdqpOut__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* sdqpOut__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* sdqpOut__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* sdqpOut__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* sdqpOut__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* sdqpOut__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::sdqpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* sdqpOut__16(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::sdqpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* sdqpOut__17(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* sdqpOut__18(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* sdqpOut__19(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* sdqpOut__20(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* sdqpOut__21(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* sdqpOut__22(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpOut" ===============
// cppName: "casadi::sdqpOut"
// cWrapperName: "sdqpOut__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* sdqpOut__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* sdqpOut__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* sdqpOut__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::sdqpOut(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpStruct" ===============
// cppName: "casadi::sdqpStruct"
// cWrapperName: "sdqpStruct__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::sdqpStruct(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* sdqpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::sdqpStruct(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpStruct" ===============
// cppName: "casadi::sdqpStruct"
// cWrapperName: "sdqpStruct__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::sdqpStruct(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* sdqpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::sdqpStruct(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpStruct" ===============
// cppName: "casadi::sdqpStruct"
// cWrapperName: "sdqpStruct__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::sdqpStruct(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* sdqpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::sdqpStruct(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpStruct" ===============
// cppName: "casadi::sdqpStruct"
// cWrapperName: "sdqpStruct__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::sdqpStruct(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* sdqpStruct__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::sdqpStruct(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sdqpStruct" ===============
// cppName: "casadi::sdqpStruct"
// cWrapperName: "sdqpStruct__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* sdqpStruct__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::sdqpStruct(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* sdqpStruct__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* sdqpStruct__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::sdqpStruct(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::simplify" ===============
// cppName: "casadi::simplify"
// cWrapperName: "simplify__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "MX"))]
// retType: CVoid
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void simplify__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::simplify(x0_)"
extern "C"
    void simplify__0(std::string ** err_msg, casadi::MX* x0);
void simplify__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    casadi::simplify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::simplify" ===============
// cppName: "casadi::simplify"
// cWrapperName: "simplify__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
// retType: CVoid
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void simplify__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::simplify(x0_)"
extern "C"
    void simplify__1(std::string ** err_msg, casadi::SX* x0);
void simplify__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    casadi::simplify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::socpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* socpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::socpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* socpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* socpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* socpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* socpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* socpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* socpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* socpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* socpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* socpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::Sparsity* >* socpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::Sparsity > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::socpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* socpIn__11(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::socpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* socpIn__12(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* socpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* socpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* socpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* socpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* socpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* socpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* socpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* socpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::MX* >* socpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::MX* >* socpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::MX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::socpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* socpIn__22(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::socpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* socpIn__23(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* socpIn__24(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* socpIn__25(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* socpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* socpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* socpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* socpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__30"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* socpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__31"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* socpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpIn" ===============
// cppName: "casadi::socpIn"
// cWrapperName: "socpIn__32"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::SX* >* socpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::SX* >* socpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::SX > ret = casadi::socpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::socpOut(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* socpOut__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::socpOut(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::socpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* socpOut__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::socpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* socpOut__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::socpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::socpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* socpOut__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::socpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::socpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* socpOut__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::socpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::socpOut(x0_)"
extern "C"
    std::vector< casadi::MX* >* socpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* socpOut__5(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::socpOut(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::socpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* socpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* socpOut__6(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::socpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* socpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* socpOut__7(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::socpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::socpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* socpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* socpOut__8(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::socpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* socpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::socpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* socpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* socpOut__9(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::socpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::socpOut(x0_)"
extern "C"
    std::vector< casadi::SX* >* socpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* socpOut__10(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::socpOut(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::socpOut(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* socpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* socpOut__11(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::socpOut(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpOut(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* socpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* socpOut__12(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::socpOut(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::socpOut(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* socpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* socpOut__13(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::socpOut(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpOut" ===============
// cppName: "casadi::socpOut"
// cWrapperName: "socpOut__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* socpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::socpOut(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* socpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* socpOut__14(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::socpOut(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpStruct" ===============
// cppName: "casadi::socpStruct"
// cWrapperName: "socpStruct__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::socpStruct(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* socpStruct__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::socpStruct(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpStruct" ===============
// cppName: "casadi::socpStruct"
// cWrapperName: "socpStruct__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::socpStruct(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* socpStruct__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::socpStruct(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::socpStruct" ===============
// cppName: "casadi::socpStruct"
// cWrapperName: "socpStruct__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* socpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::socpStruct(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* socpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* socpStruct__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::socpStruct(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::solve" ===============
// cppName: "casadi::solve"
// cWrapperName: "solve__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* solve__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::solve(x0_, x1_)"
extern "C"
    casadi::MX* solve__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* solve__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::solve(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::solve" ===============
// cppName: "casadi::solve"
// cWrapperName: "solve__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* solve__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::solve(x0_, x1_)"
extern "C"
    casadi::SX* solve__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* solve__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::solve(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::solve" ===============
// cppName: "casadi::solve"
// cWrapperName: "solve__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* solve__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::solve(x0_, x1_)"
extern "C"
    casadi::DMatrix* solve__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* solve__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::solve(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::solve" ===============
// cppName: "casadi::solve"
// cWrapperName: "solve__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* solve__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::solve(x0_, x1_)"
extern "C"
    casadi::IMatrix* solve__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* solve__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::solve(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sparse" ===============
// cppName: "casadi::sparse"
// cWrapperName: "sparse__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* sparse__0(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::sparse(x0_)"
extern "C"
    casadi::SX* sparse__0(std::string ** err_msg, casadi::SX* x0);
casadi::SX* sparse__0(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::sparse(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sparse" ===============
// cppName: "casadi::sparse"
// cWrapperName: "sparse__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, double x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CDouble]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* sparse__1(std::string ** err_msg, casadi::SX* x0, double x1)"
// call: "casadi::sparse(x0_, x1_)"
extern "C"
    casadi::SX* sparse__1(std::string ** err_msg, casadi::SX* x0, double x1);
casadi::SX* sparse__1(std::string ** err_msg, casadi::SX* x0, double x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);

        casadi::SX ret = casadi::sparse(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sparse" ===============
// cppName: "casadi::sparse"
// cWrapperName: "sparse__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* sparse__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::sparse(x0_)"
extern "C"
    casadi::DMatrix* sparse__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* sparse__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::sparse(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sparse" ===============
// cppName: "casadi::sparse"
// cWrapperName: "sparse__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, double x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CDouble]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* sparse__3(std::string ** err_msg, casadi::DMatrix* x0, double x1)"
// call: "casadi::sparse(x0_, x1_)"
extern "C"
    casadi::DMatrix* sparse__3(std::string ** err_msg, casadi::DMatrix* x0, double x1);
casadi::DMatrix* sparse__3(std::string ** err_msg, casadi::DMatrix* x0, double x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);

        casadi::DMatrix ret = casadi::sparse(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sparse" ===============
// cppName: "casadi::sparse"
// cWrapperName: "sparse__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* sparse__4(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::sparse(x0_)"
extern "C"
    casadi::IMatrix* sparse__4(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* sparse__4(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::sparse(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sparse" ===============
// cppName: "casadi::sparse"
// cWrapperName: "sparse__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, double x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CDouble]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* sparse__5(std::string ** err_msg, casadi::IMatrix* x0, double x1)"
// call: "casadi::sparse(x0_, x1_)"
extern "C"
    casadi::IMatrix* sparse__5(std::string ** err_msg, casadi::IMatrix* x0, double x1);
casadi::IMatrix* sparse__5(std::string ** err_msg, casadi::IMatrix* x0, double x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);

        casadi::IMatrix ret = casadi::sparse(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sprank" ===============
// cppName: "casadi::sprank"
// cWrapperName: "sprank__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int sprank__0(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::sprank(x0_)"
extern "C"
    int sprank__0(std::string ** err_msg, casadi::SX* x0);
int sprank__0(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        int ret = casadi::sprank(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sprank" ===============
// cppName: "casadi::sprank"
// cWrapperName: "sprank__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int sprank__1(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::sprank(x0_)"
extern "C"
    int sprank__1(std::string ** err_msg, casadi::DMatrix* x0);
int sprank__1(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        int ret = casadi::sprank(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sprank" ===============
// cppName: "casadi::sprank"
// cWrapperName: "sprank__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int sprank__2(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::sprank(x0_)"
extern "C"
    int sprank__2(std::string ** err_msg, casadi::IMatrix* x0);
int sprank__2(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        int ret = casadi::sprank(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::spy" ===============
// cppName: "casadi::spy"
// cWrapperName: "spy"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* spy(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::spy(x0_)"
extern "C"
    casadi::SX* spy(std::string ** err_msg, casadi::SX* x0);
casadi::SX* spy(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::spy(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::stabilizedQpIn(x0_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
std::vector< casadi::Sparsity* >* stabilizedQpIn__0(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1)"
// call: "casadi::stabilizedQpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1);
std::vector< casadi::Sparsity* >* stabilizedQpIn__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::Sparsity* >* stabilizedQpIn__2(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::Sparsity* >* stabilizedQpIn__3(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::Sparsity* >* stabilizedQpIn__4(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__5"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::Sparsity* >* stabilizedQpIn__5(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::Sparsity* >* stabilizedQpIn__6(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::Sparsity* >* stabilizedQpIn__7(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__8"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::Sparsity* >* stabilizedQpIn__8(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__9"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::Sparsity* >* stabilizedQpIn__9(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__10"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::Sparsity* >* stabilizedQpIn__10(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__11"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::Sparsity* >* stabilizedQpIn__11(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__12"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* stabilizedQpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::Sparsity* >* stabilizedQpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::Sparsity* >* stabilizedQpIn__12(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::Sparsity > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__13"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::stabilizedQpIn(x0_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* stabilizedQpIn__13(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__14"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1)"
// call: "casadi::stabilizedQpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1);
std::vector< casadi::MX* >* stabilizedQpIn__14(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__15"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::MX* >* stabilizedQpIn__15(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__16"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::MX* >* stabilizedQpIn__16(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__17"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::MX* >* stabilizedQpIn__17(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__18"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::MX* >* stabilizedQpIn__18(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__19"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::MX* >* stabilizedQpIn__19(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__20"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::MX* >* stabilizedQpIn__20(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__21"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::MX* >* stabilizedQpIn__21(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__22"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::MX* >* stabilizedQpIn__22(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__23"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::MX* >* stabilizedQpIn__23(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__24"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::MX* >* stabilizedQpIn__24(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__25"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* stabilizedQpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::MX* >* stabilizedQpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::MX* >* stabilizedQpIn__25(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::MX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__26"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::stabilizedQpIn(x0_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* stabilizedQpIn__26(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__27"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1)"
// call: "casadi::stabilizedQpIn(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1);
std::vector< casadi::SX* >* stabilizedQpIn__27(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__28"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2);
std::vector< casadi::SX* >* stabilizedQpIn__28(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__29"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3);
std::vector< casadi::SX* >* stabilizedQpIn__29(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__30"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
std::vector< casadi::SX* >* stabilizedQpIn__30(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__31"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
std::vector< casadi::SX* >* stabilizedQpIn__31(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__32"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
std::vector< casadi::SX* >* stabilizedQpIn__32(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__33"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
std::vector< casadi::SX* >* stabilizedQpIn__33(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__34"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
std::vector< casadi::SX* >* stabilizedQpIn__34(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__35"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9);
std::vector< casadi::SX* >* stabilizedQpIn__35(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__36"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10);
std::vector< casadi::SX* >* stabilizedQpIn__36(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__37"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11);
std::vector< casadi::SX* >* stabilizedQpIn__37(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::stabilizedQpIn" ===============
// cppName: "casadi::stabilizedQpIn"
// cWrapperName: "stabilizedQpIn__38"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* stabilizedQpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12)"
// call: "casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
extern "C"
    std::vector< casadi::SX* >* stabilizedQpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12);
std::vector< casadi::SX* >* stabilizedQpIn__38(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8, std::string* x9, std::string* x10, std::string* x11, std::string* x12){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);
        std::string x5_ = Marshaling<std::string,std::string*>::marshal(x5);
        std::string x6_ = Marshaling<std::string,std::string*>::marshal(x6);
        std::string x7_ = Marshaling<std::string,std::string*>::marshal(x7);
        std::string x8_ = Marshaling<std::string,std::string*>::marshal(x8);
        std::string x9_ = Marshaling<std::string,std::string*>::marshal(x9);
        std::string x10_ = Marshaling<std::string,std::string*>::marshal(x10);
        std::string x11_ = Marshaling<std::string,std::string*>::marshal(x11);
        std::string x12_ = Marshaling<std::string,std::string*>::marshal(x12);

        std::vector< casadi::SX > ret = casadi::stabilizedQpIn(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::substitute" ===============
// cppName: "casadi::substitute"
// cWrapperName: "substitute__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* substitute__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2)"
// call: "casadi::substitute(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::MX* >* substitute__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2);
std::vector< casadi::MX* >* substitute__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< casadi::MX* >* x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        std::vector< casadi::MX > x1_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x1);
        std::vector< casadi::MX > x2_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::substitute(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::substitute" ===============
// cppName: "casadi::substitute"
// cWrapperName: "substitute__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* substitute__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2)"
// call: "casadi::substitute(x0_, x1_, x2_)"
extern "C"
    casadi::MX* substitute__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2);
casadi::MX* substitute__1(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1, casadi::MX* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

        casadi::MX ret = casadi::substitute(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::substitute" ===============
// cppName: "casadi::substitute"
// cWrapperName: "substitute__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* substitute__2(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
// call: "casadi::substitute(x0_, x1_, x2_)"
extern "C"
    std::vector< casadi::SX* >* substitute__2(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2);
std::vector< casadi::SX* >* substitute__2(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::substitute(x0_, x1_, x2_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::substitute" ===============
// cppName: "casadi::substitute"
// cWrapperName: "substitute__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* substitute__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::substitute(x0_, x1_, x2_)"
extern "C"
    casadi::SX* substitute__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* substitute__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::substitute(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::substituteInPlace" ===============
// cppName: "casadi::substituteInPlace"
// cWrapperName: "substituteInPlace__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void substituteInPlace__0(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2)"
// call: "casadi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void substituteInPlace__0(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2);
void substituteInPlace__0(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);

    casadi::substituteInPlace(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::substituteInPlace" ===============
// cppName: "casadi::substituteInPlace"
// cWrapperName: "substituteInPlace__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, int x3)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),CBool]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void substituteInPlace__1(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, int x3)"
// call: "casadi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void substituteInPlace__1(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, int x3);
void substituteInPlace__1(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< casadi::SX* >* x2, int x3){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        std::vector< casadi::SX > x1_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x1);
        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

    casadi::substituteInPlace(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::substituteInPlace" ===============
// cppName: "casadi::substituteInPlace"
// cWrapperName: "substituteInPlace__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX")),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void substituteInPlace__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2)"
// call: "casadi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void substituteInPlace__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2);
void substituteInPlace__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);

    casadi::substituteInPlace(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::substituteInPlace" ===============
// cppName: "casadi::substituteInPlace"
// cWrapperName: "substituteInPlace__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX")),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),CBool]
// retType: CVoid
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void substituteInPlace__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2, int x3)"
// call: "casadi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void substituteInPlace__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2, int x3);
void substituteInPlace__3(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, std::vector< casadi::SX* >* x2, int x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        std::vector< casadi::SX > x2_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

    casadi::substituteInPlace(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::substituteInPlace" ===============
// cppName: "casadi::substituteInPlace"
// cWrapperName: "substituteInPlace__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
// retType: CVoid
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void substituteInPlace__4(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::substituteInPlace(x0_, x1_)"
extern "C"
    void substituteInPlace__4(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
void substituteInPlace__4(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    casadi::substituteInPlace(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::substituteInPlace" ===============
// cppName: "casadi::substituteInPlace"
// cWrapperName: "substituteInPlace__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX")),CBool]
// retType: CVoid
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void substituteInPlace__5(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2)"
// call: "casadi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void substituteInPlace__5(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2);
void substituteInPlace__5(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

    casadi::substituteInPlace(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== function "casadi::sumAll" ===============
// cppName: "casadi::sumAll"
// cWrapperName: "sumAll__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* sumAll__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::sumAll(x0_)"
extern "C"
    casadi::MX* sumAll__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* sumAll__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::sumAll(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumAll" ===============
// cppName: "casadi::sumAll"
// cWrapperName: "sumAll__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* sumAll__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::sumAll(x0_)"
extern "C"
    casadi::SX* sumAll__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* sumAll__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::sumAll(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumAll" ===============
// cppName: "casadi::sumAll"
// cWrapperName: "sumAll__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* sumAll__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::sumAll(x0_)"
extern "C"
    casadi::DMatrix* sumAll__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* sumAll__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::sumAll(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumAll" ===============
// cppName: "casadi::sumAll"
// cWrapperName: "sumAll__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* sumAll__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::sumAll(x0_)"
extern "C"
    casadi::IMatrix* sumAll__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* sumAll__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::sumAll(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumCols" ===============
// cppName: "casadi::sumCols"
// cWrapperName: "sumCols__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* sumCols__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::sumCols(x0_)"
extern "C"
    casadi::MX* sumCols__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* sumCols__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::sumCols(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumCols" ===============
// cppName: "casadi::sumCols"
// cWrapperName: "sumCols__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* sumCols__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::sumCols(x0_)"
extern "C"
    casadi::SX* sumCols__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* sumCols__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::sumCols(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumCols" ===============
// cppName: "casadi::sumCols"
// cWrapperName: "sumCols__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* sumCols__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::sumCols(x0_)"
extern "C"
    casadi::DMatrix* sumCols__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* sumCols__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::sumCols(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumCols" ===============
// cppName: "casadi::sumCols"
// cWrapperName: "sumCols__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* sumCols__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::sumCols(x0_)"
extern "C"
    casadi::IMatrix* sumCols__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* sumCols__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::sumCols(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumRows" ===============
// cppName: "casadi::sumRows"
// cWrapperName: "sumRows__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* sumRows__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::sumRows(x0_)"
extern "C"
    casadi::MX* sumRows__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* sumRows__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::sumRows(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumRows" ===============
// cppName: "casadi::sumRows"
// cWrapperName: "sumRows__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* sumRows__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::sumRows(x0_)"
extern "C"
    casadi::SX* sumRows__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* sumRows__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::sumRows(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumRows" ===============
// cppName: "casadi::sumRows"
// cWrapperName: "sumRows__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* sumRows__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::sumRows(x0_)"
extern "C"
    casadi::DMatrix* sumRows__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* sumRows__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::sumRows(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::sumRows" ===============
// cppName: "casadi::sumRows"
// cWrapperName: "sumRows__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* sumRows__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::sumRows(x0_)"
extern "C"
    casadi::IMatrix* sumRows__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* sumRows__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::sumRows(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tangent" ===============
// cppName: "casadi::tangent"
// cWrapperName: "tangent__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* tangent__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::tangent(x0_, x1_)"
extern "C"
    casadi::MX* tangent__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* tangent__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::tangent(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tangent" ===============
// cppName: "casadi::tangent"
// cWrapperName: "tangent__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* tangent__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::tangent(x0_, x1_)"
extern "C"
    casadi::SX* tangent__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* tangent__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::tangent(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::taylor" ===============
// cppName: "casadi::taylor"
// cWrapperName: "taylor__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* taylor__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::taylor(x0_, x1_)"
extern "C"
    casadi::SX* taylor__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* taylor__0(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::taylor(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::taylor" ===============
// cppName: "casadi::taylor"
// cWrapperName: "taylor__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* taylor__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::taylor(x0_, x1_, x2_)"
extern "C"
    casadi::SX* taylor__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* taylor__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

        casadi::SX ret = casadi::taylor(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::taylor" ===============
// cppName: "casadi::taylor"
// cWrapperName: "taylor__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* taylor__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3)"
// call: "casadi::taylor(x0_, x1_, x2_, x3_)"
extern "C"
    casadi::SX* taylor__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3);
casadi::SX* taylor__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, int x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        casadi::SX ret = casadi::taylor(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::trace" ===============
// cppName: "casadi::trace"
// cWrapperName: "trace__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* trace__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::trace(x0_)"
extern "C"
    casadi::MX* trace__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* trace__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::trace(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::trace" ===============
// cppName: "casadi::trace"
// cWrapperName: "trace__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SXElement")
// args: "(x0_)"
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* trace__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::trace(x0_)"
extern "C"
    casadi::SXElement* trace__1(std::string ** err_msg, casadi::SX* x0);
casadi::SXElement* trace__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SXElement ret = casadi::trace(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::trace" ===============
// cppName: "casadi::trace"
// cWrapperName: "trace__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: CDouble
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double trace__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::trace(x0_)"
extern "C"
    double trace__2(std::string ** err_msg, casadi::DMatrix* x0);
double trace__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        double ret = casadi::trace(x0_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::trace" ===============
// cppName: "casadi::trace"
// cWrapperName: "trace__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: CInt
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int trace__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::trace(x0_)"
extern "C"
    int trace__3(std::string ** err_msg, casadi::IMatrix* x0);
int trace__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        int ret = casadi::trace(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::transpose" ===============
// cppName: "casadi::transpose"
// cWrapperName: "transpose__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* transpose__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::transpose(x0_)"
extern "C"
    casadi::MX* transpose__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* transpose__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::transpose(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::transpose" ===============
// cppName: "casadi::transpose"
// cWrapperName: "transpose__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* transpose__1(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::transpose(x0_)"
extern "C"
    casadi::Sparsity* transpose__1(std::string ** err_msg, casadi::Sparsity* x0);
casadi::Sparsity* transpose__1(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = casadi::transpose(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::transpose" ===============
// cppName: "casadi::transpose"
// cWrapperName: "transpose__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* transpose__2(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::transpose(x0_)"
extern "C"
    casadi::SX* transpose__2(std::string ** err_msg, casadi::SX* x0);
casadi::SX* transpose__2(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::transpose(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::transpose" ===============
// cppName: "casadi::transpose"
// cWrapperName: "transpose__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* transpose__3(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::transpose(x0_)"
extern "C"
    casadi::DMatrix* transpose__3(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* transpose__3(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::transpose(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::transpose" ===============
// cppName: "casadi::transpose"
// cWrapperName: "transpose__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* transpose__4(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::transpose(x0_)"
extern "C"
    casadi::IMatrix* transpose__4(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* transpose__4(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::transpose(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triangle" ===============
// cppName: "casadi::triangle"
// cWrapperName: "triangle"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* triangle(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::triangle(x0_)"
extern "C"
    casadi::SX* triangle(std::string ** err_msg, casadi::SX* x0);
casadi::SX* triangle(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::triangle(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril" ===============
// cppName: "casadi::tril"
// cWrapperName: "tril__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* tril__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::tril(x0_)"
extern "C"
    casadi::Sparsity* tril__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::Sparsity* tril__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = casadi::tril(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril" ===============
// cppName: "casadi::tril"
// cWrapperName: "tril__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* tril__1(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// call: "casadi::tril(x0_, x1_)"
extern "C"
    casadi::Sparsity* tril__1(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::Sparsity* tril__1(std::string ** err_msg, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::Sparsity ret = casadi::tril(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril" ===============
// cppName: "casadi::tril"
// cWrapperName: "tril__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* tril__2(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::tril(x0_)"
extern "C"
    casadi::MX* tril__2(std::string ** err_msg, casadi::MX* x0);
casadi::MX* tril__2(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::tril(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril" ===============
// cppName: "casadi::tril"
// cWrapperName: "tril__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* tril__3(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::tril(x0_)"
extern "C"
    casadi::SX* tril__3(std::string ** err_msg, casadi::SX* x0);
casadi::SX* tril__3(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::tril(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril" ===============
// cppName: "casadi::tril"
// cWrapperName: "tril__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* tril__4(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::tril(x0_)"
extern "C"
    casadi::DMatrix* tril__4(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* tril__4(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::tril(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril" ===============
// cppName: "casadi::tril"
// cWrapperName: "tril__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* tril__5(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::tril(x0_)"
extern "C"
    casadi::IMatrix* tril__5(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* tril__5(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::tril(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril2symm" ===============
// cppName: "casadi::tril2symm"
// cWrapperName: "tril2symm__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* tril2symm__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::tril2symm(x0_)"
extern "C"
    casadi::MX* tril2symm__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* tril2symm__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::tril2symm(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril2symm" ===============
// cppName: "casadi::tril2symm"
// cWrapperName: "tril2symm__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* tril2symm__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::tril2symm(x0_)"
extern "C"
    casadi::SX* tril2symm__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* tril2symm__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::tril2symm(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril2symm" ===============
// cppName: "casadi::tril2symm"
// cWrapperName: "tril2symm__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* tril2symm__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::tril2symm(x0_)"
extern "C"
    casadi::DMatrix* tril2symm__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* tril2symm__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::tril2symm(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::tril2symm" ===============
// cppName: "casadi::tril2symm"
// cWrapperName: "tril2symm__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* tril2symm__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::tril2symm(x0_)"
extern "C"
    casadi::IMatrix* tril2symm__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* tril2symm__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::tril2symm(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu" ===============
// cppName: "casadi::triu"
// cWrapperName: "triu__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* triu__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::triu(x0_)"
extern "C"
    casadi::Sparsity* triu__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::Sparsity* triu__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = casadi::triu(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu" ===============
// cppName: "casadi::triu"
// cWrapperName: "triu__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* triu__1(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// call: "casadi::triu(x0_, x1_)"
extern "C"
    casadi::Sparsity* triu__1(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::Sparsity* triu__1(std::string ** err_msg, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::Sparsity ret = casadi::triu(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu" ===============
// cppName: "casadi::triu"
// cWrapperName: "triu__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* triu__2(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::triu(x0_)"
extern "C"
    casadi::MX* triu__2(std::string ** err_msg, casadi::MX* x0);
casadi::MX* triu__2(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::triu(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu" ===============
// cppName: "casadi::triu"
// cWrapperName: "triu__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* triu__3(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::triu(x0_)"
extern "C"
    casadi::SX* triu__3(std::string ** err_msg, casadi::SX* x0);
casadi::SX* triu__3(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::triu(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu" ===============
// cppName: "casadi::triu"
// cWrapperName: "triu__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* triu__4(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::triu(x0_)"
extern "C"
    casadi::DMatrix* triu__4(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* triu__4(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::triu(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu" ===============
// cppName: "casadi::triu"
// cWrapperName: "triu__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* triu__5(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::triu(x0_)"
extern "C"
    casadi::IMatrix* triu__5(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* triu__5(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::triu(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu2symm" ===============
// cppName: "casadi::triu2symm"
// cWrapperName: "triu2symm__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* triu2symm__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::triu2symm(x0_)"
extern "C"
    casadi::MX* triu2symm__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* triu2symm__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::triu2symm(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu2symm" ===============
// cppName: "casadi::triu2symm"
// cWrapperName: "triu2symm__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* triu2symm__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::triu2symm(x0_)"
extern "C"
    casadi::SX* triu2symm__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* triu2symm__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::triu2symm(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu2symm" ===============
// cppName: "casadi::triu2symm"
// cWrapperName: "triu2symm__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* triu2symm__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::triu2symm(x0_)"
extern "C"
    casadi::DMatrix* triu2symm__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* triu2symm__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::triu2symm(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::triu2symm" ===============
// cppName: "casadi::triu2symm"
// cWrapperName: "triu2symm__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* triu2symm__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::triu2symm(x0_)"
extern "C"
    casadi::IMatrix* triu2symm__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* triu2symm__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::triu2symm(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::unite" ===============
// cppName: "casadi::unite"
// cWrapperName: "unite__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* unite__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1)"
// call: "casadi::unite(x0_, x1_)"
extern "C"
    casadi::MX* unite__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1);
casadi::MX* unite__0(std::string ** err_msg, casadi::MX* x0, casadi::MX* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::unite(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::unite" ===============
// cppName: "casadi::unite"
// cWrapperName: "unite__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* unite__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1)"
// call: "casadi::unite(x0_, x1_)"
extern "C"
    casadi::SX* unite__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1);
casadi::SX* unite__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::unite(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::unite" ===============
// cppName: "casadi::unite"
// cWrapperName: "unite__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* unite__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1)"
// call: "casadi::unite(x0_, x1_)"
extern "C"
    casadi::DMatrix* unite__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1);
casadi::DMatrix* unite__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::DMatrix ret = casadi::unite(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::unite" ===============
// cppName: "casadi::unite"
// cWrapperName: "unite__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_, x1_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* unite__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "casadi::unite(x0_, x1_)"
extern "C"
    casadi::IMatrix* unite__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* unite__3(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::IMatrix ret = casadi::unite(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vec" ===============
// cppName: "casadi::vec"
// cWrapperName: "vec__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* vec__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::vec(x0_)"
extern "C"
    casadi::MX* vec__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* vec__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::vec(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vec" ===============
// cppName: "casadi::vec"
// cWrapperName: "vec__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* vec__1(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::vec(x0_)"
extern "C"
    casadi::Sparsity* vec__1(std::string ** err_msg, casadi::Sparsity* x0);
casadi::Sparsity* vec__1(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = casadi::vec(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vec" ===============
// cppName: "casadi::vec"
// cWrapperName: "vec__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* vec__2(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::vec(x0_)"
extern "C"
    casadi::SX* vec__2(std::string ** err_msg, casadi::SX* x0);
casadi::SX* vec__2(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::vec(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vec" ===============
// cppName: "casadi::vec"
// cWrapperName: "vec__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* vec__3(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::vec(x0_)"
extern "C"
    casadi::DMatrix* vec__3(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* vec__3(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::vec(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vec" ===============
// cppName: "casadi::vec"
// cWrapperName: "vec__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* vec__4(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::vec(x0_)"
extern "C"
    casadi::IMatrix* vec__4(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* vec__4(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::vec(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZ" ===============
// cppName: "casadi::vecNZ"
// cWrapperName: "vecNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* vecNZ__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::vecNZ(x0_)"
extern "C"
    casadi::MX* vecNZ__0(std::string ** err_msg, casadi::MX* x0);
casadi::MX* vecNZ__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        casadi::MX ret = casadi::vecNZ(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZ" ===============
// cppName: "casadi::vecNZ"
// cWrapperName: "vecNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* vecNZ__1(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::vecNZ(x0_)"
extern "C"
    casadi::SX* vecNZ__1(std::string ** err_msg, casadi::SX* x0);
casadi::SX* vecNZ__1(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::vecNZ(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZ" ===============
// cppName: "casadi::vecNZ"
// cWrapperName: "vecNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* vecNZ__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::vecNZ(x0_)"
extern "C"
    casadi::DMatrix* vecNZ__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* vecNZ__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::DMatrix ret = casadi::vecNZ(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZ" ===============
// cppName: "casadi::vecNZ"
// cWrapperName: "vecNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* vecNZ__3(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::vecNZ(x0_)"
extern "C"
    casadi::IMatrix* vecNZ__3(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* vecNZ__3(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::IMatrix ret = casadi::vecNZ(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZcat" ===============
// cppName: "casadi::vecNZcat"
// cWrapperName: "vecNZcat__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* vecNZcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::vecNZcat(x0_)"
extern "C"
    casadi::MX* vecNZcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* vecNZcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::vecNZcat(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZcat" ===============
// cppName: "casadi::vecNZcat"
// cWrapperName: "vecNZcat__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* vecNZcat__1(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::vecNZcat(x0_)"
extern "C"
    casadi::SX* vecNZcat__1(std::string ** err_msg, std::vector< casadi::SX* >* x0);
casadi::SX* vecNZcat__1(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SX ret = casadi::vecNZcat(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZcat" ===============
// cppName: "casadi::vecNZcat"
// cWrapperName: "vecNZcat__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* vecNZcat__2(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// call: "casadi::vecNZcat(x0_)"
extern "C"
    casadi::DMatrix* vecNZcat__2(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0);
casadi::DMatrix* vecNZcat__2(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::vecNZcat(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vecNZcat" ===============
// cppName: "casadi::vecNZcat"
// cWrapperName: "vecNZcat__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* vecNZcat__3(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// call: "casadi::vecNZcat(x0_)"
extern "C"
    casadi::IMatrix* vecNZcat__3(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0);
casadi::IMatrix* vecNZcat__3(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0){
    try {
        std::vector< casadi::IMatrix > x0_ = Marshaling<std::vector< casadi::IMatrix >,std::vector< casadi::IMatrix* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::vecNZcat(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::veccat" ===============
// cppName: "casadi::veccat"
// cWrapperName: "veccat__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* veccat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::veccat(x0_)"
extern "C"
    casadi::MX* veccat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* veccat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::veccat(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::veccat" ===============
// cppName: "casadi::veccat"
// cWrapperName: "veccat__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* veccat__1(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::veccat(x0_)"
extern "C"
    casadi::SX* veccat__1(std::string ** err_msg, std::vector< casadi::SX* >* x0);
casadi::SX* veccat__1(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SX ret = casadi::veccat(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::veccat" ===============
// cppName: "casadi::veccat"
// cWrapperName: "veccat__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* veccat__2(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// call: "casadi::veccat(x0_)"
extern "C"
    casadi::DMatrix* veccat__2(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0);
casadi::DMatrix* veccat__2(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::veccat(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::veccat" ===============
// cppName: "casadi::veccat"
// cWrapperName: "veccat__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* veccat__3(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// call: "casadi::veccat(x0_)"
extern "C"
    casadi::IMatrix* veccat__3(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0);
casadi::IMatrix* veccat__3(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0){
    try {
        std::vector< casadi::IMatrix > x0_ = Marshaling<std::vector< casadi::IMatrix >,std::vector< casadi::IMatrix* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::veccat(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertcat" ===============
// cppName: "casadi::vertcat"
// cWrapperName: "vertcat__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "MX")
// args: "(x0_)"
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* vertcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0)"
// call: "casadi::vertcat(x0_)"
extern "C"
    casadi::MX* vertcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0);
casadi::MX* vertcat__0(std::string ** err_msg, std::vector< casadi::MX* >* x0){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);

        casadi::MX ret = casadi::vertcat(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertcat" ===============
// cppName: "casadi::vertcat"
// cWrapperName: "vertcat__1"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
// retType: UserType (Namespace ["casadi"]) (Name "Sparsity")
// args: "(x0_)"
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* vertcat__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0)"
// call: "casadi::vertcat(x0_)"
extern "C"
    casadi::Sparsity* vertcat__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0);
casadi::Sparsity* vertcat__1(std::string ** err_msg, std::vector< casadi::Sparsity* >* x0){
    try {
        std::vector< casadi::Sparsity > x0_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x0);

        casadi::Sparsity ret = casadi::vertcat(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertcat" ===============
// cppName: "casadi::vertcat"
// cWrapperName: "vertcat__2"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
// retType: UserType (Namespace ["casadi"]) (Name "SX")
// args: "(x0_)"
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* vertcat__2(std::string ** err_msg, std::vector< casadi::SX* >* x0)"
// call: "casadi::vertcat(x0_)"
extern "C"
    casadi::SX* vertcat__2(std::string ** err_msg, std::vector< casadi::SX* >* x0);
casadi::SX* vertcat__2(std::string ** err_msg, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SX ret = casadi::vertcat(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertcat" ===============
// cppName: "casadi::vertcat"
// cWrapperName: "vertcat__3"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "DMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* vertcat__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0)"
// call: "casadi::vertcat(x0_)"
extern "C"
    casadi::DMatrix* vertcat__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0);
casadi::DMatrix* vertcat__3(std::string ** err_msg, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        casadi::DMatrix ret = casadi::vertcat(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertcat" ===============
// cppName: "casadi::vertcat"
// cWrapperName: "vertcat__4"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))))]
// retType: UserType (Namespace ["casadi"]) (Name "IMatrix")
// args: "(x0_)"
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* vertcat__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0)"
// call: "casadi::vertcat(x0_)"
extern "C"
    casadi::IMatrix* vertcat__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0);
casadi::IMatrix* vertcat__4(std::string ** err_msg, std::vector< casadi::IMatrix* >* x0){
    try {
        std::vector< casadi::IMatrix > x0_ = Marshaling<std::vector< casadi::IMatrix >,std::vector< casadi::IMatrix* >*>::marshal(x0);

        casadi::IMatrix ret = casadi::vertcat(x0_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* vertsplit__0(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::vertsplit(x0_)"
extern "C"
    std::vector< casadi::MX* >* vertsplit__0(std::string ** err_msg, casadi::MX* x0);
std::vector< casadi::MX* >* vertsplit__0(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

        std::vector< casadi::MX > ret = casadi::vertsplit(x0_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* vertsplit__1(std::string ** err_msg, casadi::MX* x0, int x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* vertsplit__1(std::string ** err_msg, casadi::MX* x0, int x1);
std::vector< casadi::MX* >* vertsplit__1(std::string ** err_msg, casadi::MX* x0, int x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* vertsplit__2(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::MX* >* vertsplit__2(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1);
std::vector< casadi::MX* >* vertsplit__2(std::string ** err_msg, casadi::MX* x0, std::vector< int >* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::MX > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::MX* >*, std::vector< casadi::MX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::Sparsity* >*"
// proto: "std::vector< casadi::Sparsity* >* vertsplit__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::Sparsity* >* vertsplit__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1);
std::vector< casadi::Sparsity* >* vertsplit__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::Sparsity > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::Sparsity* >*, std::vector< casadi::Sparsity > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* vertsplit__4(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::vertsplit(x0_)"
extern "C"
    std::vector< casadi::SX* >* vertsplit__4(std::string ** err_msg, casadi::SX* x0);
std::vector< casadi::SX* >* vertsplit__4(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        std::vector< casadi::SX > ret = casadi::vertsplit(x0_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* vertsplit__5(std::string ** err_msg, casadi::SX* x0, int x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* vertsplit__5(std::string ** err_msg, casadi::SX* x0, int x1);
std::vector< casadi::SX* >* vertsplit__5(std::string ** err_msg, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__6"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* vertsplit__6(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::SX* >* vertsplit__6(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1);
std::vector< casadi::SX* >* vertsplit__6(std::string ** err_msg, casadi::SX* x0, std::vector< int >* x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::SX > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::SX* >*, std::vector< casadi::SX > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__7"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* vertsplit__7(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::vertsplit(x0_)"
extern "C"
    std::vector< casadi::DMatrix* >* vertsplit__7(std::string ** err_msg, casadi::DMatrix* x0);
std::vector< casadi::DMatrix* >* vertsplit__7(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        std::vector< casadi::DMatrix > ret = casadi::vertsplit(x0_);
        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__8"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* vertsplit__8(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::DMatrix* >* vertsplit__8(std::string ** err_msg, casadi::DMatrix* x0, int x1);
std::vector< casadi::DMatrix* >* vertsplit__8(std::string ** err_msg, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::DMatrix > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__9"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* vertsplit__9(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::DMatrix* >* vertsplit__9(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1);
std::vector< casadi::DMatrix* >* vertsplit__9(std::string ** err_msg, casadi::DMatrix* x0, std::vector< int >* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::DMatrix > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::DMatrix* >*, std::vector< casadi::DMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__10"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// args: "(x0_)"
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* vertsplit__10(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::vertsplit(x0_)"
extern "C"
    std::vector< casadi::IMatrix* >* vertsplit__10(std::string ** err_msg, casadi::IMatrix* x0);
std::vector< casadi::IMatrix* >* vertsplit__10(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        std::vector< casadi::IMatrix > ret = casadi::vertsplit(x0_);
        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__11"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* vertsplit__11(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::IMatrix* >* vertsplit__11(std::string ** err_msg, casadi::IMatrix* x0, int x1);
std::vector< casadi::IMatrix* >* vertsplit__11(std::string ** err_msg, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< casadi::IMatrix > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== function "casadi::vertsplit" ===============
// cppName: "casadi::vertsplit"
// cWrapperName: "vertsplit__12"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
// retType: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* vertsplit__12(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "casadi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< casadi::IMatrix* >* vertsplit__12(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1);
std::vector< casadi::IMatrix* >* vertsplit__12(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< casadi::IMatrix > ret = casadi::vertsplit(x0_, x1_);
        return WrapReturn< std::vector< casadi::IMatrix* >*, std::vector< casadi::IMatrix > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}