casadi-bindings-core-1.9.0.3: cbits/autogen/core_classes.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"

// ================== delete UserType (Namespace ["casadi"]) (Name "Callback")===============
// classType: UserType (Namespace ["casadi"]) (Name "Callback")
extern "C"
    void delete_casadi__Callback(casadi::Callback* obj);
void delete_casadi__Callback(casadi::Callback* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Callback"
// cppName: "casadi::Callback"
// cWrapperName: "casadi__Callback__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Callback")
// cWrapperRetType: "casadi::Callback*"
// proto: "casadi::Callback* casadi__Callback__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::Callback()"
// params: []
extern "C"
    casadi::Callback* casadi__Callback__CONSTRUCTOR(std::string ** err_msg);
casadi::Callback* casadi__Callback__CONSTRUCTOR(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "CasadiMeta")===============
// classType: UserType (Namespace ["casadi"]) (Name "CasadiMeta")
extern "C"
    void delete_casadi__CasadiMeta(casadi::CasadiMeta* obj);
void delete_casadi__CasadiMeta(casadi::CasadiMeta* obj){
    delete obj;
}

// ================== Static method: "getBuildType" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getBuildType"
// cWrapperName: "casadi__CasadiMeta__getBuildType"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getBuildType(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getBuildType()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getBuildType(std::string ** err_msg);
std::string* casadi__CasadiMeta__getBuildType(std::string ** err_msg){
    try {

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


// ================== Static method: "getCompiler" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getCompiler"
// cWrapperName: "casadi__CasadiMeta__getCompiler"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getCompiler(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getCompiler()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getCompiler(std::string ** err_msg);
std::string* casadi__CasadiMeta__getCompiler(std::string ** err_msg){
    try {

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


// ================== Static method: "getCompilerFlags" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getCompilerFlags"
// cWrapperName: "casadi__CasadiMeta__getCompilerFlags"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getCompilerFlags()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg);
std::string* casadi__CasadiMeta__getCompilerFlags(std::string ** err_msg){
    try {

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


// ================== Static method: "getCompilerId" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getCompilerId"
// cWrapperName: "casadi__CasadiMeta__getCompilerId"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getCompilerId(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getCompilerId()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getCompilerId(std::string ** err_msg);
std::string* casadi__CasadiMeta__getCompilerId(std::string ** err_msg){
    try {

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


// ================== Static method: "getFeatureList" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getFeatureList"
// cWrapperName: "casadi__CasadiMeta__getFeatureList"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getFeatureList(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getFeatureList()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getFeatureList(std::string ** err_msg);
std::string* casadi__CasadiMeta__getFeatureList(std::string ** err_msg){
    try {

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


// ================== Static method: "getGitDescribe" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getGitDescribe"
// cWrapperName: "casadi__CasadiMeta__getGitDescribe"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getGitDescribe(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getGitDescribe()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getGitDescribe(std::string ** err_msg);
std::string* casadi__CasadiMeta__getGitDescribe(std::string ** err_msg){
    try {

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


// ================== Static method: "getGitRevision" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getGitRevision"
// cWrapperName: "casadi__CasadiMeta__getGitRevision"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getGitRevision(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getGitRevision()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getGitRevision(std::string ** err_msg);
std::string* casadi__CasadiMeta__getGitRevision(std::string ** err_msg){
    try {

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


// ================== Static method: "getModules" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getModules"
// cWrapperName: "casadi__CasadiMeta__getModules"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getModules(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getModules()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getModules(std::string ** err_msg);
std::string* casadi__CasadiMeta__getModules(std::string ** err_msg){
    try {

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


// ================== Static method: "getVersion" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getVersion"
// cWrapperName: "casadi__CasadiMeta__getVersion"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getVersion(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getVersion()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getVersion(std::string ** err_msg);
std::string* casadi__CasadiMeta__getVersion(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "CasadiOptions")===============
// classType: UserType (Namespace ["casadi"]) (Name "CasadiOptions")
extern "C"
    void delete_casadi__CasadiOptions(casadi::CasadiOptions* obj);
void delete_casadi__CasadiOptions(casadi::CasadiOptions* obj){
    delete obj;
}

// ================== Static method: "getAllowedInternalAPI" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::getAllowedInternalAPI"
// cWrapperName: "casadi__CasadiOptions__getAllowedInternalAPI"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__CasadiOptions__getAllowedInternalAPI(std::string ** err_msg)"
// call: "casadi::CasadiOptions::getAllowedInternalAPI()"
// params: []
extern "C"
    int casadi__CasadiOptions__getAllowedInternalAPI(std::string ** err_msg);
int casadi__CasadiOptions__getAllowedInternalAPI(std::string ** err_msg){
    try {

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


// ================== Static method: "getCatchErrorsPython" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::getCatchErrorsPython"
// cWrapperName: "casadi__CasadiOptions__getCatchErrorsPython"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__CasadiOptions__getCatchErrorsPython(std::string ** err_msg)"
// call: "casadi::CasadiOptions::getCatchErrorsPython()"
// params: []
extern "C"
    int casadi__CasadiOptions__getCatchErrorsPython(std::string ** err_msg);
int casadi__CasadiOptions__getCatchErrorsPython(std::string ** err_msg){
    try {

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


// ================== Static method: "getProfilingBinary" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::getProfilingBinary"
// cWrapperName: "casadi__CasadiOptions__getProfilingBinary"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__CasadiOptions__getProfilingBinary(std::string ** err_msg)"
// call: "casadi::CasadiOptions::getProfilingBinary()"
// params: []
extern "C"
    int casadi__CasadiOptions__getProfilingBinary(std::string ** err_msg);
int casadi__CasadiOptions__getProfilingBinary(std::string ** err_msg){
    try {

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


// ================== Static method: "getSimplificationOnTheFly" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::getSimplificationOnTheFly"
// cWrapperName: "casadi__CasadiOptions__getSimplificationOnTheFly"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__CasadiOptions__getSimplificationOnTheFly(std::string ** err_msg)"
// call: "casadi::CasadiOptions::getSimplificationOnTheFly()"
// params: []
extern "C"
    int casadi__CasadiOptions__getSimplificationOnTheFly(std::string ** err_msg);
int casadi__CasadiOptions__getSimplificationOnTheFly(std::string ** err_msg){
    try {

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


// ================== Static method: "setAllowedInternalAPI" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setAllowedInternalAPI"
// cWrapperName: "casadi__CasadiOptions__setAllowedInternalAPI"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__setAllowedInternalAPI(std::string ** err_msg, int x0)"
// call: "casadi::CasadiOptions::setAllowedInternalAPI(x0_)"
// params: [CBool]
extern "C"
    void casadi__CasadiOptions__setAllowedInternalAPI(std::string ** err_msg, int x0);
void casadi__CasadiOptions__setAllowedInternalAPI(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Static method: "setCatchErrorsPython" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setCatchErrorsPython"
// cWrapperName: "casadi__CasadiOptions__setCatchErrorsPython"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__setCatchErrorsPython(std::string ** err_msg, int x0)"
// call: "casadi::CasadiOptions::setCatchErrorsPython(x0_)"
// params: [CBool]
extern "C"
    void casadi__CasadiOptions__setCatchErrorsPython(std::string ** err_msg, int x0);
void casadi__CasadiOptions__setCatchErrorsPython(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Static method: "setProfilingBinary" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setProfilingBinary"
// cWrapperName: "casadi__CasadiOptions__setProfilingBinary"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__setProfilingBinary(std::string ** err_msg, int x0)"
// call: "casadi::CasadiOptions::setProfilingBinary(x0_)"
// params: [CBool]
extern "C"
    void casadi__CasadiOptions__setProfilingBinary(std::string ** err_msg, int x0);
void casadi__CasadiOptions__setProfilingBinary(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Static method: "setPurgeSeeds" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setPurgeSeeds"
// cWrapperName: "casadi__CasadiOptions__setPurgeSeeds__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__CasadiOptions__setPurgeSeeds__0(std::string ** err_msg)"
// call: "casadi::CasadiOptions::setPurgeSeeds()"
// params: []
extern "C"
    int casadi__CasadiOptions__setPurgeSeeds__0(std::string ** err_msg);
int casadi__CasadiOptions__setPurgeSeeds__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setPurgeSeeds" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setPurgeSeeds"
// cWrapperName: "casadi__CasadiOptions__setPurgeSeeds__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__setPurgeSeeds__1(std::string ** err_msg, int x0)"
// call: "casadi::CasadiOptions::setPurgeSeeds(x0_)"
// params: [CBool]
extern "C"
    void casadi__CasadiOptions__setPurgeSeeds__1(std::string ** err_msg, int x0);
void casadi__CasadiOptions__setPurgeSeeds__1(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Static method: "setSimplificationOnTheFly" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setSimplificationOnTheFly"
// cWrapperName: "casadi__CasadiOptions__setSimplificationOnTheFly"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0)"
// call: "casadi::CasadiOptions::setSimplificationOnTheFly(x0_)"
// params: [CBool]
extern "C"
    void casadi__CasadiOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0);
void casadi__CasadiOptions__setSimplificationOnTheFly(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Static method: "startProfiling" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::startProfiling"
// cWrapperName: "casadi__CasadiOptions__startProfiling"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__startProfiling(std::string ** err_msg, std::string* x0)"
// call: "casadi::CasadiOptions::startProfiling(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__CasadiOptions__startProfiling(std::string ** err_msg, std::string* x0);
void casadi__CasadiOptions__startProfiling(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Static method: "stopProfiling" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::stopProfiling"
// cWrapperName: "casadi__CasadiOptions__stopProfiling"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__stopProfiling(std::string ** err_msg)"
// call: "casadi::CasadiOptions::stopProfiling()"
// params: []
extern "C"
    void casadi__CasadiOptions__stopProfiling(std::string ** err_msg);
void casadi__CasadiOptions__stopProfiling(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "ControlSimulator")===============
// classType: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
extern "C"
    void delete_casadi__ControlSimulator(casadi::ControlSimulator* obj);
void delete_casadi__ControlSimulator(casadi::ControlSimulator* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator"
// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
// cWrapperRetType: "casadi::ControlSimulator*"
// proto: "casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__0(std::string ** err_msg, casadi::Function* x0, casadi::DMatrix* x1)"
// call: "casadi::ControlSimulator(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__0(std::string ** err_msg, casadi::Function* x0, casadi::DMatrix* x1);
casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__0(std::string ** err_msg, casadi::Function* x0, casadi::DMatrix* x1){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator"
// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
// cWrapperRetType: "casadi::ControlSimulator*"
// proto: "casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0, std::vector< double >* x1)"
// call: "casadi::ControlSimulator(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdVec CDouble))]
extern "C"
    casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0, std::vector< double >* x1);
casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0, std::vector< double >* x1){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator"
// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, casadi::DMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
// cWrapperRetType: "casadi::ControlSimulator*"
// proto: "casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__2(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, casadi::DMatrix* x2)"
// call: "casadi::ControlSimulator(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__2(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, casadi::DMatrix* x2);
casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__2(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, casadi::DMatrix* x2){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator"
// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
// cWrapperRetType: "casadi::ControlSimulator*"
// proto: "casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, std::vector< double >* x2)"
// call: "casadi::ControlSimulator(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdVec CDouble))]
extern "C"
    casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, std::vector< double >* x2);
casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1, std::vector< double >* x2){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);
        std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator"
// cWrapperName: "casadi__ControlSimulator__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "ControlSimulator")
// cWrapperRetType: "casadi::ControlSimulator*"
// proto: "casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__4(std::string ** err_msg)"
// call: "casadi::ControlSimulator()"
// params: []
extern "C"
    casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__4(std::string ** err_msg);
casadi::ControlSimulator* casadi__ControlSimulator__CONSTRUCTOR__4(std::string ** err_msg){
    try {

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


// ================== Normal method: "getMajorIndex" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator::getMajorIndex"
// cWrapperName: "casadi__ControlSimulator__getMajorIndex"
// protoArgs: "(std::string ** err_msg, casadi::ControlSimulator* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__ControlSimulator__getMajorIndex(std::string ** err_msg, casadi::ControlSimulator* obj)"
// call: "obj->getMajorIndex()"
// params: []
extern "C"
    std::vector< int >* casadi__ControlSimulator__getMajorIndex(std::string ** err_msg, casadi::ControlSimulator* obj);
std::vector< int >* casadi__ControlSimulator__getMajorIndex(std::string ** err_msg, casadi::ControlSimulator* obj){
    try {

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


// ================== Normal method: "getMinorT" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator::getMinorT"
// cWrapperName: "casadi__ControlSimulator__getMinorT"
// protoArgs: "(std::string ** err_msg, casadi::ControlSimulator* obj)"
// args: "()"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* casadi__ControlSimulator__getMinorT(std::string ** err_msg, casadi::ControlSimulator* obj)"
// call: "obj->getMinorT()"
// params: []
extern "C"
    std::vector< double >* casadi__ControlSimulator__getMinorT(std::string ** err_msg, casadi::ControlSimulator* obj);
std::vector< double >* casadi__ControlSimulator__getMinorT(std::string ** err_msg, casadi::ControlSimulator* obj){
    try {

        std::vector< double > ret = obj->getMinorT();
        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getMinorU" ===============
// class: "casadi::ControlSimulator"
// cppName: "casadi::ControlSimulator::getMinorU"
// cWrapperName: "casadi__ControlSimulator__getMinorU"
// protoArgs: "(std::string ** err_msg, casadi::ControlSimulator* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__ControlSimulator__getMinorU(std::string ** err_msg, casadi::ControlSimulator* obj)"
// call: "obj->getMinorU()"
// params: []
extern "C"
    casadi::DMatrix* casadi__ControlSimulator__getMinorU(std::string ** err_msg, casadi::ControlSimulator* obj);
casadi::DMatrix* casadi__ControlSimulator__getMinorU(std::string ** err_msg, casadi::ControlSimulator* obj){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "CustomEvaluate")===============
// classType: UserType (Namespace ["casadi"]) (Name "CustomEvaluate")
extern "C"
    void delete_casadi__CustomEvaluate(casadi::CustomEvaluate* obj);
void delete_casadi__CustomEvaluate(casadi::CustomEvaluate* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::CustomEvaluate"
// cppName: "casadi::CustomEvaluate"
// cWrapperName: "casadi__CustomEvaluate__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "CustomEvaluate")
// cWrapperRetType: "casadi::CustomEvaluate*"
// proto: "casadi::CustomEvaluate* casadi__CustomEvaluate__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::CustomEvaluate()"
// params: []
extern "C"
    casadi::CustomEvaluate* casadi__CustomEvaluate__CONSTRUCTOR(std::string ** err_msg);
casadi::CustomEvaluate* casadi__CustomEvaluate__CONSTRUCTOR(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "CustomFunction")===============
// classType: UserType (Namespace ["casadi"]) (Name "CustomFunction")
extern "C"
    void delete_casadi__CustomFunction(casadi::CustomFunction* obj);
void delete_casadi__CustomFunction(casadi::CustomFunction* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::CustomFunction"
// cppName: "casadi::CustomFunction"
// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::CustomEvaluate* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
// cWrapperRetType: "casadi::CustomFunction*"
// proto: "casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__0(std::string ** err_msg, casadi::CustomEvaluate* x0)"
// call: "casadi::CustomFunction(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate")))]
extern "C"
    casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__0(std::string ** err_msg, casadi::CustomEvaluate* x0);
casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__0(std::string ** err_msg, casadi::CustomEvaluate* x0){
    try {
        casadi::CustomEvaluate x0_ = Marshaling<casadi::CustomEvaluate,casadi::CustomEvaluate*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::CustomFunction"
// cppName: "casadi::CustomFunction"
// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::CustomEvaluate* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
// cWrapperRetType: "casadi::CustomFunction*"
// proto: "casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::CustomEvaluate* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2)"
// call: "casadi::CustomFunction(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "CustomEvaluate"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
extern "C"
    casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::CustomEvaluate* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2);
casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::CustomEvaluate* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2){
    try {
        casadi::CustomEvaluate x0_ = Marshaling<casadi::CustomEvaluate,casadi::CustomEvaluate*>::marshal(x0);
        std::vector< casadi::Sparsity > x1_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x1);
        std::vector< casadi::Sparsity > x2_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x2);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::CustomFunction"
// cppName: "casadi::CustomFunction"
// cWrapperName: "casadi__CustomFunction__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "CustomFunction")
// cWrapperRetType: "casadi::CustomFunction*"
// proto: "casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__2(std::string ** err_msg)"
// call: "casadi::CustomFunction()"
// params: []
extern "C"
    casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__2(std::string ** err_msg);
casadi::CustomFunction* casadi__CustomFunction__CONSTRUCTOR__2(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "DMatrix")===============
// classType: UserType (Namespace ["casadi"]) (Name "DMatrix")
extern "C"
    void delete_casadi__DMatrix(casadi::DMatrix* obj);
void delete_casadi__DMatrix(casadi::DMatrix* obj){
    delete obj;
}

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

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::DMatrix(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__2(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::DMatrix(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__2(std::string ** err_msg, casadi::IMatrix* x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__2(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__3(std::string ** err_msg, std::vector< double >* x0, int x1, int x2)"
// call: "casadi::DMatrix(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CDouble)),CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__3(std::string ** err_msg, std::vector< double >* x0, int x1, int x2);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__3(std::string ** err_msg, std::vector< double >* x0, int x1, int x2){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__4(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::DMatrix(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__4(std::string ** err_msg, std::vector< double >* x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__4(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__5(std::string ** err_msg, double x0)"
// call: "casadi::DMatrix(x0_)"
// params: [CDouble]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__5(std::string ** err_msg, double x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__5(std::string ** err_msg, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__6"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, std::vector< double >* x1)"
// call: "casadi::DMatrix(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (StdVec CDouble))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, std::vector< double >* x1);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0, std::vector< double >* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__7"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::DMatrix(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__8"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, double* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__8(std::string ** err_msg, casadi::Sparsity* x0, double* x1)"
// call: "casadi::DMatrix(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const CDouble)]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__8(std::string ** err_msg, casadi::Sparsity* x0, double* x1);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__8(std::string ** err_msg, casadi::Sparsity* x0, double* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__9"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__9(std::string ** err_msg, std::vector< std::vector< double >* >* x0)"
// call: "casadi::DMatrix(x0_)"
// params: [Ref (Const (StdVec (StdVec CDouble)))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__9(std::string ** err_msg, std::vector< std::vector< double >* >* x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__9(std::string ** err_msg, std::vector< std::vector< double >* >* x0){
    try {
        std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__10"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__10(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::DMatrix(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__10(std::string ** err_msg, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__10(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix"
// cWrapperName: "casadi__DMatrix__CONSTRUCTOR__11"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__11(std::string ** err_msg)"
// call: "casadi::DMatrix()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__11(std::string ** err_msg);
casadi::DMatrix* casadi__DMatrix__CONSTRUCTOR__11(std::string ** err_msg){
    try {

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


// ================== Normal method: "__add__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__add__"
// cWrapperName: "casadi__DMatrix____add__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____add__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__add__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____add__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____add__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__constpow__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__constpow__"
// cWrapperName: "casadi__DMatrix____constpow__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____constpow__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__constpow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____constpow__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____constpow__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__copysign__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__copysign__"
// cWrapperName: "casadi__DMatrix____copysign__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____copysign__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__copysign__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____copysign__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____copysign__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__div__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__div__"
// cWrapperName: "casadi__DMatrix____div__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____div__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__div__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____div__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____div__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__eq__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__eq__"
// cWrapperName: "casadi__DMatrix____eq__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____eq__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__eq__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____eq__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____eq__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__ge__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__ge__"
// cWrapperName: "casadi__DMatrix____ge__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____ge__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__ge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____ge__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____ge__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__gt__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__gt__"
// cWrapperName: "casadi__DMatrix____gt__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____gt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__gt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____gt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____gt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__le__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__le__"
// cWrapperName: "casadi__DMatrix____le__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____le__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__le__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____le__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____le__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__lt__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__lt__"
// cWrapperName: "casadi__DMatrix____lt__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____lt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__lt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____lt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____lt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__mldivide__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__mldivide__"
// cWrapperName: "casadi__DMatrix____mldivide__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____mldivide__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__mldivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____mldivide__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____mldivide__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__mpower__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__mpower__"
// cWrapperName: "casadi__DMatrix____mpower__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____mpower__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__mpower__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____mpower__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____mpower__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__mrdivide__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__mrdivide__"
// cWrapperName: "casadi__DMatrix____mrdivide__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____mrdivide__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__mrdivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____mrdivide__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____mrdivide__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__mul__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__mul__"
// cWrapperName: "casadi__DMatrix____mul__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____mul__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__mul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____mul__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____mul__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__ne__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__ne__"
// cWrapperName: "casadi__DMatrix____ne__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____ne__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__ne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____ne__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____ne__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__nonzero__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__nonzero__"
// cWrapperName: "casadi__DMatrix____nonzero__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix____nonzero__(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->__nonzero__()"
// params: []
extern "C"
    int casadi__DMatrix____nonzero__(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix____nonzero__(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "__pow__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__pow__"
// cWrapperName: "casadi__DMatrix____pow__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____pow__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__pow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____pow__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____pow__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__radd__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__radd__"
// cWrapperName: "casadi__DMatrix____radd__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____radd__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__radd__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____radd__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____radd__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rdiv__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rdiv__"
// cWrapperName: "casadi__DMatrix____rdiv__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rdiv__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rdiv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rdiv__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rdiv__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__req__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__req__"
// cWrapperName: "casadi__DMatrix____req__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____req__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__req__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____req__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____req__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rge__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rge__"
// cWrapperName: "casadi__DMatrix____rge__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rge__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rge__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rge__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rgt__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rgt__"
// cWrapperName: "casadi__DMatrix____rgt__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rgt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rgt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rgt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rgt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rle__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rle__"
// cWrapperName: "casadi__DMatrix____rle__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rle__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rle__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rle__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rle__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rlt__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rlt__"
// cWrapperName: "casadi__DMatrix____rlt__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rlt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rlt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rlt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rlt__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rmul__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rmul__"
// cWrapperName: "casadi__DMatrix____rmul__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rmul__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rmul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rmul__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rmul__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rne__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rne__"
// cWrapperName: "casadi__DMatrix____rne__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rne__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rne__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rne__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rsub__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rsub__"
// cWrapperName: "casadi__DMatrix____rsub__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rsub__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rsub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rsub__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rsub__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__rtruediv__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__rtruediv__"
// cWrapperName: "casadi__DMatrix____rtruediv__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____rtruediv__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__rtruediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____rtruediv__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____rtruediv__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__sub__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__sub__"
// cWrapperName: "casadi__DMatrix____sub__"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____sub__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__sub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____sub__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____sub__(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__truediv__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__truediv__"
// cWrapperName: "casadi__DMatrix____truediv____0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____truediv____0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____truediv____0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____truediv____0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "__truediv__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__truediv__"
// cWrapperName: "casadi__DMatrix____truediv____1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix____truediv____1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix____truediv____1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____truediv____1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "append" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::append"
// cWrapperName: "casadi__DMatrix__append"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__append(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->append(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__append(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
void casadi__DMatrix__append(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

    obj->append(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "appendColumns" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::appendColumns"
// cWrapperName: "casadi__DMatrix__appendColumns"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__appendColumns(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->appendColumns(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__appendColumns(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
void casadi__DMatrix__appendColumns(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

    obj->appendColumns(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "arccos" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arccos"
// cWrapperName: "casadi__DMatrix__arccos"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arccos(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->arccos()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__arccos(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__arccos(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "arccosh" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arccosh"
// cWrapperName: "casadi__DMatrix__arccosh"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arccosh(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->arccosh()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__arccosh(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__arccosh(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "arcsin" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arcsin"
// cWrapperName: "casadi__DMatrix__arcsin"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arcsin(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->arcsin()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__arcsin(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__arcsin(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "arcsinh" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arcsinh"
// cWrapperName: "casadi__DMatrix__arcsinh"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arcsinh(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->arcsinh()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__arcsinh(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__arcsinh(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "arctan" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arctan"
// cWrapperName: "casadi__DMatrix__arctan"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arctan(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->arctan()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__arctan(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__arctan(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "arctan2" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arctan2"
// cWrapperName: "casadi__DMatrix__arctan2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arctan2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->arctan2(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__arctan2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__arctan2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "arctanh" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::arctanh"
// cWrapperName: "casadi__DMatrix__arctanh"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__arctanh(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->arctanh()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__arctanh(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__arctanh(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "at" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::at"
// cWrapperName: "casadi__DMatrix__at"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__at(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->at(x0_)"
// params: [CInt]
extern "C"
    double casadi__DMatrix__at(std::string ** err_msg, casadi::DMatrix* obj, int x0);
double casadi__DMatrix__at(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


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

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


// ================== Normal method: "ceil" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::ceil"
// cWrapperName: "casadi__DMatrix__ceil"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__ceil(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->ceil()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__ceil(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__ceil(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Static method: "className" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::className"
// cWrapperName: "casadi__DMatrix__className"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__DMatrix__className(std::string ** err_msg)"
// call: "casadi::DMatrix::className()"
// params: []
extern "C"
    std::string* casadi__DMatrix__className(std::string ** err_msg);
std::string* casadi__DMatrix__className(std::string ** err_msg){
    try {

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


// ================== Normal method: "clear" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::clear"
// cWrapperName: "casadi__DMatrix__clear"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__clear(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->clear()"
// params: []
extern "C"
    void casadi__DMatrix__clear(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__clear(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->clear();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "colind" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::colind"
// cWrapperName: "casadi__DMatrix__colind__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__colind__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->colind(x0_)"
// params: [CInt]
extern "C"
    int casadi__DMatrix__colind__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
int casadi__DMatrix__colind__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "colind" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::colind"
// cWrapperName: "casadi__DMatrix__colind__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__DMatrix__colind__1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->colind()"
// params: []
extern "C"
    std::vector< int >* casadi__DMatrix__colind__1(std::string ** err_msg, casadi::DMatrix* obj);
std::vector< int >* casadi__DMatrix__colind__1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "cos" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::cos"
// cWrapperName: "casadi__DMatrix__cos"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__cos(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->cos()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__cos(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__cos(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "cosh" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::cosh"
// cWrapperName: "casadi__DMatrix__cosh"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__cosh(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->cosh()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__cosh(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__cosh(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "data" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::data"
// cWrapperName: "casadi__DMatrix__data__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: Const (StdVec CDouble)
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* casadi__DMatrix__data__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->data()"
// params: []
extern "C"
    std::vector< double >* casadi__DMatrix__data__0(std::string ** err_msg, casadi::DMatrix* obj);
std::vector< double >* casadi__DMatrix__data__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

        std::vector< double > ret = obj->data();
        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "data" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::data"
// cWrapperName: "casadi__DMatrix__data__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* casadi__DMatrix__data__1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->data()"
// params: []
extern "C"
    std::vector< double >* casadi__DMatrix__data__1(std::string ** err_msg, casadi::DMatrix* obj);
std::vector< double >* casadi__DMatrix__data__1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

        std::vector< double > ret = obj->data();
        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "densify" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::densify"
// cWrapperName: "casadi__DMatrix__densify__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__densify__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->densify()"
// params: []
extern "C"
    void casadi__DMatrix__densify__0(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__densify__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->densify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "densify" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::densify"
// cWrapperName: "casadi__DMatrix__densify__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__densify__1(std::string ** err_msg, casadi::DMatrix* obj, double* x0)"
// call: "obj->densify(x0_)"
// params: [Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__densify__1(std::string ** err_msg, casadi::DMatrix* obj, double* x0);
void casadi__DMatrix__densify__1(std::string ** err_msg, casadi::DMatrix* obj, double* x0){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);

    obj->densify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "dimString" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::dimString"
// cWrapperName: "casadi__DMatrix__dimString"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__DMatrix__dimString(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->dimString()"
// params: []
extern "C"
    std::string* casadi__DMatrix__dimString(std::string ** err_msg, casadi::DMatrix* obj);
std::string* casadi__DMatrix__dimString(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "elem" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::elem"
// cWrapperName: "casadi__DMatrix__elem__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__elem__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->elem(x0_)"
// params: [CInt]
extern "C"
    double casadi__DMatrix__elem__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
double casadi__DMatrix__elem__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "elem" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::elem"
// cWrapperName: "casadi__DMatrix__elem__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__elem__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->elem(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    double casadi__DMatrix__elem__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
double casadi__DMatrix__elem__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "enlarge" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::enlarge"
// cWrapperName: "casadi__DMatrix__enlarge"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__enlarge(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__enlarge(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void casadi__DMatrix__enlarge(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

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


// ================== Normal method: "erase" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::erase"
// cWrapperName: "casadi__DMatrix__erase"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__erase(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__erase(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__DMatrix__erase(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->erase(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "erf" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::erf"
// cWrapperName: "casadi__DMatrix__erf"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__erf(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->erf()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__erf(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__erf(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "erfinv" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::erfinv"
// cWrapperName: "casadi__DMatrix__erfinv"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__erfinv(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->erfinv()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__erfinv(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__erfinv(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "exp" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::exp"
// cWrapperName: "casadi__DMatrix__exp"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__exp(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->exp()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__exp(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__exp(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Static method: "eye" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::eye"
// cWrapperName: "casadi__DMatrix__eye"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__eye(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::eye(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__eye(std::string ** err_msg, int x0);
casadi::DMatrix* casadi__DMatrix__eye(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "fabs" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::fabs"
// cWrapperName: "casadi__DMatrix__fabs"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__fabs(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->fabs()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__fabs(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__fabs(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "floor" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::floor"
// cWrapperName: "casadi__DMatrix__floor"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__floor(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->floor()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__floor(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__floor(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "fmax" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::fmax"
// cWrapperName: "casadi__DMatrix__fmax"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__fmax(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->fmax(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__fmax(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__fmax(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "fmin" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::fmin"
// cWrapperName: "casadi__DMatrix__fmin"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__fmin(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->fmin(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__fmin(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__fmin(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "fmod" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::fmod"
// cWrapperName: "casadi__DMatrix__fmod"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__fmod(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->fmod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__fmod(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__fmod(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "get" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::get"
// cWrapperName: "casadi__DMatrix__get__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__get__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->get(x0_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix"))]
extern "C"
    void casadi__DMatrix__get__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
void casadi__DMatrix__get__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::get"
// cWrapperName: "casadi__DMatrix__get__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__get__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__DMatrix__get__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1);
void casadi__DMatrix__get__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::get"
// cWrapperName: "casadi__DMatrix__get__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__get__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
// call: "obj->get(x0_)"
// params: [Ref (StdVec CDouble)]
extern "C"
    void casadi__DMatrix__get__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
void casadi__DMatrix__get__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::get"
// cWrapperName: "casadi__DMatrix__get__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__get__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (StdVec CDouble),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__DMatrix__get__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1);
void casadi__DMatrix__get__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::get"
// cWrapperName: "casadi__DMatrix__get__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__get__4(std::string ** err_msg, casadi::DMatrix* obj, double* x0)"
// call: "obj->get(x0_)"
// params: [Ref CDouble]
extern "C"
    void casadi__DMatrix__get__4(std::string ** err_msg, casadi::DMatrix* obj, double* x0);
void casadi__DMatrix__get__4(std::string ** err_msg, casadi::DMatrix* obj, double* x0){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::get"
// cWrapperName: "casadi__DMatrix__get__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__get__5(std::string ** err_msg, casadi::DMatrix* obj, double* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref CDouble,CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__DMatrix__get__5(std::string ** err_msg, casadi::DMatrix* obj, double* x0, int x1);
void casadi__DMatrix__get__5(std::string ** err_msg, casadi::DMatrix* obj, double* x0, int x1){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getElement" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getElement"
// cWrapperName: "casadi__DMatrix__getElement__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__getElement__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->getElement(x0_)"
// params: [CInt]
extern "C"
    double casadi__DMatrix__getElement__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
double casadi__DMatrix__getElement__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "getElement" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getElement"
// cWrapperName: "casadi__DMatrix__getElement__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__getElement__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->getElement(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    double casadi__DMatrix__getElement__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
double casadi__DMatrix__getElement__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getEqualityCheckingDepth"
// cWrapperName: "casadi__DMatrix__getEqualityCheckingDepth"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__getEqualityCheckingDepth(std::string ** err_msg)"
// call: "casadi::DMatrix::getEqualityCheckingDepth()"
// params: []
extern "C"
    int casadi__DMatrix__getEqualityCheckingDepth(std::string ** err_msg);
int casadi__DMatrix__getEqualityCheckingDepth(std::string ** err_msg){
    try {

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


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getMaxNumCallsInPrint"
// cWrapperName: "casadi__DMatrix__getMaxNumCallsInPrint"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long casadi__DMatrix__getMaxNumCallsInPrint(std::string ** err_msg)"
// call: "casadi::DMatrix::getMaxNumCallsInPrint()"
// params: []
extern "C"
    long casadi__DMatrix__getMaxNumCallsInPrint(std::string ** err_msg);
long casadi__DMatrix__getMaxNumCallsInPrint(std::string ** err_msg){
    try {

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getNZ"
// cWrapperName: "casadi__DMatrix__getNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__getNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__getNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0);
casadi::DMatrix* casadi__DMatrix__getNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getNZ"
// cWrapperName: "casadi__DMatrix__getNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__getNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__getNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0);
casadi::DMatrix* casadi__DMatrix__getNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getNZ"
// cWrapperName: "casadi__DMatrix__getNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__getNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__getNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0);
casadi::DMatrix* casadi__DMatrix__getNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getNZ"
// cWrapperName: "casadi__DMatrix__getNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__getNZ__3(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->getNZ(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__getNZ__3(std::string ** err_msg, casadi::DMatrix* obj, int x0);
casadi::DMatrix* casadi__DMatrix__getNZ__3(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "getName" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getName"
// cWrapperName: "casadi__DMatrix__getName"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__DMatrix__getName(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->getName()"
// params: []
extern "C"
    std::string* casadi__DMatrix__getName(std::string ** err_msg, casadi::DMatrix* obj);
std::string* casadi__DMatrix__getName(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "getValue" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getValue"
// cWrapperName: "casadi__DMatrix__getValue"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__getValue(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->getValue()"
// params: []
extern "C"
    double casadi__DMatrix__getValue(std::string ** err_msg, casadi::DMatrix* obj);
double casadi__DMatrix__getValue(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "hasNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::hasNZ"
// cWrapperName: "casadi__DMatrix__hasNZ"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__hasNZ(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__DMatrix__hasNZ(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
int casadi__DMatrix__hasNZ(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "hasNonStructuralZeros" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::hasNonStructuralZeros"
// cWrapperName: "casadi__DMatrix__hasNonStructuralZeros"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->hasNonStructuralZeros()"
// params: []
extern "C"
    int casadi__DMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "if_else_zero" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::if_else_zero"
// cWrapperName: "casadi__DMatrix__if_else_zero"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__if_else_zero(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->if_else_zero(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__if_else_zero(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__if_else_zero(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed"
// cWrapperName: "casadi__DMatrix__indexed__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0);
casadi::DMatrix* casadi__DMatrix__indexed__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed"
// cWrapperName: "casadi__DMatrix__indexed__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__indexed__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed"
// cWrapperName: "casadi__DMatrix__indexed__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::DMatrix* casadi__DMatrix__indexed__2(std::string ** err_msg, casadi::DMatrix* obj, 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::DMatrix ret = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed"
// cWrapperName: "casadi__DMatrix__indexed__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::DMatrix* casadi__DMatrix__indexed__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed"
// cWrapperName: "casadi__DMatrix__indexed__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::DMatrix* casadi__DMatrix__indexed__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed"
// cWrapperName: "casadi__DMatrix__indexed__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::DMatrix* casadi__DMatrix__indexed__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_assignment"
// cWrapperName: "casadi__DMatrix__indexed_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1);
void casadi__DMatrix__indexed_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_assignment"
// cWrapperName: "casadi__DMatrix__indexed_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, casadi::DMatrix* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, casadi::DMatrix* x1);
void casadi__DMatrix__indexed_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, casadi::DMatrix* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_assignment"
// cWrapperName: "casadi__DMatrix__indexed_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::DMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::DMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::DMatrix* x2);
void casadi__DMatrix__indexed_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::DMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_assignment"
// cWrapperName: "casadi__DMatrix__indexed_assignment__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::DMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_assignment__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::DMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_assignment__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::DMatrix* x2);
void casadi__DMatrix__indexed_assignment__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::DMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_assignment"
// cWrapperName: "casadi__DMatrix__indexed_assignment__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::DMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_assignment__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::DMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_assignment__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::DMatrix* x2);
void casadi__DMatrix__indexed_assignment__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::DMatrix* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_assignment"
// cWrapperName: "casadi__DMatrix__indexed_assignment__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::DMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_assignment__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::DMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_assignment__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::DMatrix* x2);
void casadi__DMatrix__indexed_assignment__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::DMatrix* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_one_based"
// cWrapperName: "casadi__DMatrix__indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed_one_based__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed_one_based__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
casadi::DMatrix* casadi__DMatrix__indexed_one_based__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_one_based"
// cWrapperName: "casadi__DMatrix__indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed_one_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->indexed_one_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed_one_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__indexed_one_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_one_based"
// cWrapperName: "casadi__DMatrix__indexed_one_based__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed_one_based__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed_one_based__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0);
casadi::DMatrix* casadi__DMatrix__indexed_one_based__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_one_based_assignment"
// cWrapperName: "casadi__DMatrix__indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_one_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__indexed_one_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1);
void casadi__DMatrix__indexed_one_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_one_based_assignment"
// cWrapperName: "casadi__DMatrix__indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_one_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__indexed_one_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2);
void casadi__DMatrix__indexed_one_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        double x2_ = Marshaling<double,double*>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_one_based_assignment"
// cWrapperName: "casadi__DMatrix__indexed_one_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_one_based_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_one_based_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1);
void casadi__DMatrix__indexed_one_based_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_zero_based"
// cWrapperName: "casadi__DMatrix__indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed_zero_based__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed_zero_based__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
casadi::DMatrix* casadi__DMatrix__indexed_zero_based__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_zero_based"
// cWrapperName: "casadi__DMatrix__indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed_zero_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->indexed_zero_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed_zero_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__indexed_zero_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_zero_based"
// cWrapperName: "casadi__DMatrix__indexed_zero_based__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__indexed_zero_based__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__indexed_zero_based__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0);
casadi::DMatrix* casadi__DMatrix__indexed_zero_based__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_zero_based_assignment"
// cWrapperName: "casadi__DMatrix__indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1);
void casadi__DMatrix__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_zero_based_assignment"
// cWrapperName: "casadi__DMatrix__indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2);
void casadi__DMatrix__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1, double* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        double x2_ = Marshaling<double,double*>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::indexed_zero_based_assignment"
// cWrapperName: "casadi__DMatrix__indexed_zero_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1);
void casadi__DMatrix__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::inf"
// cWrapperName: "casadi__DMatrix__inf__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__inf__0(std::string ** err_msg)"
// call: "casadi::DMatrix::inf()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__inf__0(std::string ** err_msg);
casadi::DMatrix* casadi__DMatrix__inf__0(std::string ** err_msg){
    try {

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


// ================== Static method: "inf" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::inf"
// cWrapperName: "casadi__DMatrix__inf__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__inf__1(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::inf(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__inf__1(std::string ** err_msg, int x0);
casadi::DMatrix* casadi__DMatrix__inf__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "inf" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::inf"
// cWrapperName: "casadi__DMatrix__inf__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__inf__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::DMatrix::inf(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__inf__2(std::string ** err_msg, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__inf__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "inf" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::inf"
// cWrapperName: "casadi__DMatrix__inf__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__inf__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::DMatrix::inf(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__inf__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__inf__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "isConstant" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isConstant"
// cWrapperName: "casadi__DMatrix__isConstant"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isConstant(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isConstant()"
// params: []
extern "C"
    int casadi__DMatrix__isConstant(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isConstant(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isDense" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isDense"
// cWrapperName: "casadi__DMatrix__isDense"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isDense(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isDense()"
// params: []
extern "C"
    int casadi__DMatrix__isDense(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isDense(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isEmpty" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isEmpty"
// cWrapperName: "casadi__DMatrix__isEmpty__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isEmpty__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isEmpty()"
// params: []
extern "C"
    int casadi__DMatrix__isEmpty__0(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isEmpty__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isEmpty" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isEmpty"
// cWrapperName: "casadi__DMatrix__isEmpty__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isEmpty__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->isEmpty(x0_)"
// params: [CBool]
extern "C"
    int casadi__DMatrix__isEmpty__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
int casadi__DMatrix__isEmpty__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "isEqual" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isEqual"
// cWrapperName: "casadi__DMatrix__isEqual"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isEqual(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->isEqual(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    int casadi__DMatrix__isEqual(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
int casadi__DMatrix__isEqual(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "isIdentity" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isIdentity"
// cWrapperName: "casadi__DMatrix__isIdentity"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isIdentity(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isIdentity()"
// params: []
extern "C"
    int casadi__DMatrix__isIdentity(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isIdentity(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isInteger" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isInteger"
// cWrapperName: "casadi__DMatrix__isInteger"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isInteger(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isInteger()"
// params: []
extern "C"
    int casadi__DMatrix__isInteger(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isInteger(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isMinusOne" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isMinusOne"
// cWrapperName: "casadi__DMatrix__isMinusOne"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isMinusOne(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isMinusOne()"
// params: []
extern "C"
    int casadi__DMatrix__isMinusOne(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isMinusOne(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isOne" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isOne"
// cWrapperName: "casadi__DMatrix__isOne"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isOne(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isOne()"
// params: []
extern "C"
    int casadi__DMatrix__isOne(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isOne(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isRegular" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isRegular"
// cWrapperName: "casadi__DMatrix__isRegular"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isRegular(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isRegular()"
// params: []
extern "C"
    int casadi__DMatrix__isRegular(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isRegular(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isScalar" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isScalar"
// cWrapperName: "casadi__DMatrix__isScalar__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isScalar__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isScalar()"
// params: []
extern "C"
    int casadi__DMatrix__isScalar__0(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isScalar__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isScalar" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isScalar"
// cWrapperName: "casadi__DMatrix__isScalar__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isScalar__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->isScalar(x0_)"
// params: [CBool]
extern "C"
    int casadi__DMatrix__isScalar__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
int casadi__DMatrix__isScalar__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "isSmooth" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isSmooth"
// cWrapperName: "casadi__DMatrix__isSmooth"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isSmooth(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isSmooth()"
// params: []
extern "C"
    int casadi__DMatrix__isSmooth(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isSmooth(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isSquare" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isSquare"
// cWrapperName: "casadi__DMatrix__isSquare"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isSquare(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isSquare()"
// params: []
extern "C"
    int casadi__DMatrix__isSquare(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isSquare(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isSymbolic" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isSymbolic"
// cWrapperName: "casadi__DMatrix__isSymbolic"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isSymbolic(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isSymbolic()"
// params: []
extern "C"
    int casadi__DMatrix__isSymbolic(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isSymbolic(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isSymbolicSparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isSymbolicSparse"
// cWrapperName: "casadi__DMatrix__isSymbolicSparse"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isSymbolicSparse(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isSymbolicSparse()"
// params: []
extern "C"
    int casadi__DMatrix__isSymbolicSparse(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isSymbolicSparse(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isTril" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isTril"
// cWrapperName: "casadi__DMatrix__isTril"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isTril(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isTril()"
// params: []
extern "C"
    int casadi__DMatrix__isTril(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isTril(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isTriu" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isTriu"
// cWrapperName: "casadi__DMatrix__isTriu"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isTriu(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isTriu()"
// params: []
extern "C"
    int casadi__DMatrix__isTriu(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isTriu(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isVector" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isVector"
// cWrapperName: "casadi__DMatrix__isVector"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isVector(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isVector()"
// params: []
extern "C"
    int casadi__DMatrix__isVector(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isVector(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "isZero" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::isZero"
// cWrapperName: "casadi__DMatrix__isZero"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__isZero(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->isZero()"
// params: []
extern "C"
    int casadi__DMatrix__isZero(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__isZero(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "log" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::log"
// cWrapperName: "casadi__DMatrix__log"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__log(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->log()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__log(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__log(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "log10" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::log10"
// cWrapperName: "casadi__DMatrix__log10"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__log10(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->log10()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__log10(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__log10(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "logic_and" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::logic_and"
// cWrapperName: "casadi__DMatrix__logic_and"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__logic_and(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->logic_and(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__logic_and(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__logic_and(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "logic_not" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::logic_not"
// cWrapperName: "casadi__DMatrix__logic_not"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__logic_not(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->logic_not()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__logic_not(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__logic_not(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "logic_or" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::logic_or"
// cWrapperName: "casadi__DMatrix__logic_or"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__logic_or(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->logic_or(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__logic_or(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__logic_or(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


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

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


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

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


// ================== Normal method: "mul" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul"
// cWrapperName: "casadi__DMatrix__mul__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__mul__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->mul(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__mul__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__mul__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "mul" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul"
// cWrapperName: "casadi__DMatrix__mul__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__mul__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__mul__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1);
casadi::DMatrix* casadi__DMatrix__mul__1(std::string ** err_msg, casadi::DMatrix* obj, 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 = obj->mul(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul_full" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul_full"
// cWrapperName: "casadi__DMatrix__mul_full__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__mul_full__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->mul_full(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__mul_full__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__mul_full__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Normal method: "mul_full" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul_full"
// cWrapperName: "casadi__DMatrix__mul_full__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__mul_full__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__mul_full__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1);
casadi::DMatrix* casadi__DMatrix__mul_full__1(std::string ** err_msg, casadi::DMatrix* obj, 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 = obj->mul_full(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul_no_alloc_nn"
// cWrapperName: "casadi__DMatrix__mul_no_alloc_nn__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__mul_no_alloc_nn__0(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2)"
// call: "casadi::DMatrix::mul_no_alloc_nn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CDouble)),Ref (StdVec CDouble)]
extern "C"
    void casadi__DMatrix__mul_no_alloc_nn__0(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2);
void casadi__DMatrix__mul_no_alloc_nn__0(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::DMatrix::mul_no_alloc_nn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

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


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

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


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul_no_alloc_tn"
// cWrapperName: "casadi__DMatrix__mul_no_alloc_tn__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__mul_no_alloc_tn__0(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2)"
// call: "casadi::DMatrix::mul_no_alloc_tn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CDouble)),Ref (StdVec CDouble)]
extern "C"
    void casadi__DMatrix__mul_no_alloc_tn__0(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1, std::vector< double >* x2);
void casadi__DMatrix__mul_no_alloc_tn__0(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::DMatrix::mul_no_alloc_tn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

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


// ================== Normal method: "mul_smart" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::mul_smart"
// cWrapperName: "casadi__DMatrix__mul_smart"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__mul_smart(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__mul_smart(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1);
casadi::DMatrix* casadi__DMatrix__mul_smart(std::string ** err_msg, casadi::DMatrix* obj, 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 = obj->mul_smart(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nan"
// cWrapperName: "casadi__DMatrix__nan__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nan__0(std::string ** err_msg)"
// call: "casadi::DMatrix::nan()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__nan__0(std::string ** err_msg);
casadi::DMatrix* casadi__DMatrix__nan__0(std::string ** err_msg){
    try {

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


// ================== Static method: "nan" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nan"
// cWrapperName: "casadi__DMatrix__nan__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nan__1(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::nan(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nan__1(std::string ** err_msg, int x0);
casadi::DMatrix* casadi__DMatrix__nan__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "nan" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nan"
// cWrapperName: "casadi__DMatrix__nan__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nan__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::DMatrix::nan(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nan__2(std::string ** err_msg, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__nan__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "nan" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nan"
// cWrapperName: "casadi__DMatrix__nan__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nan__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::DMatrix::nan(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nan__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__nan__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "numel" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::numel"
// cWrapperName: "casadi__DMatrix__numel"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__numel(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->numel()"
// params: []
extern "C"
    int casadi__DMatrix__numel(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__numel(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "nz_indexed" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed"
// cWrapperName: "casadi__DMatrix__nz_indexed"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nz_indexed(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0)"
// call: "obj->nz_indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nz_indexed(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0);
casadi::DMatrix* casadi__DMatrix__nz_indexed(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_assignment"
// cWrapperName: "casadi__DMatrix__nz_indexed_assignment"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__nz_indexed_assignment(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__nz_indexed_assignment(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1);
void casadi__DMatrix__nz_indexed_assignment(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_one_based"
// cWrapperName: "casadi__DMatrix__nz_indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nz_indexed_one_based__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nz_indexed_one_based__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0);
casadi::DMatrix* casadi__DMatrix__nz_indexed_one_based__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_one_based"
// cWrapperName: "casadi__DMatrix__nz_indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nz_indexed_one_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nz_indexed_one_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
casadi::DMatrix* casadi__DMatrix__nz_indexed_one_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__DMatrix__nz_indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1);
void casadi__DMatrix__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__DMatrix__nz_indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1);
void casadi__DMatrix__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_zero_based"
// cWrapperName: "casadi__DMatrix__nz_indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nz_indexed_zero_based__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nz_indexed_zero_based__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0);
casadi::DMatrix* casadi__DMatrix__nz_indexed_zero_based__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_zero_based"
// cWrapperName: "casadi__DMatrix__nz_indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__nz_indexed_zero_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__nz_indexed_zero_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
casadi::DMatrix* casadi__DMatrix__nz_indexed_zero_based__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__DMatrix__nz_indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1);
void casadi__DMatrix__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__DMatrix__nz_indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1);
void casadi__DMatrix__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::DMatrix* obj, int x0, double* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        double x1_ = Marshaling<double,double*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::ones"
// cWrapperName: "casadi__DMatrix__ones__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__ones__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::DMatrix::ones(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__ones__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__ones__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Static method: "ones" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::ones"
// cWrapperName: "casadi__DMatrix__ones__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__ones__1(std::string ** err_msg)"
// call: "casadi::DMatrix::ones()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__ones__1(std::string ** err_msg);
casadi::DMatrix* casadi__DMatrix__ones__1(std::string ** err_msg){
    try {

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


// ================== Static method: "ones" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::ones"
// cWrapperName: "casadi__DMatrix__ones__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__ones__2(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::ones(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__ones__2(std::string ** err_msg, int x0);
casadi::DMatrix* casadi__DMatrix__ones__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "ones" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::ones"
// cWrapperName: "casadi__DMatrix__ones__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__ones__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::DMatrix::ones(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__ones__3(std::string ** err_msg, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__ones__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "printDense" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::printDense"
// cWrapperName: "casadi__DMatrix__printDense"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__printDense(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->printDense()"
// params: []
extern "C"
    void casadi__DMatrix__printDense(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__printDense(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->printDense();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printScalar" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::printScalar"
// cWrapperName: "casadi__DMatrix__printScalar"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__printScalar(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->printScalar()"
// params: []
extern "C"
    void casadi__DMatrix__printScalar(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__printScalar(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->printScalar();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printSparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::printSparse"
// cWrapperName: "casadi__DMatrix__printSparse"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__printSparse(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->printSparse()"
// params: []
extern "C"
    void casadi__DMatrix__printSparse(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__printSparse(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->printSparse();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printVector" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::printVector"
// cWrapperName: "casadi__DMatrix__printVector"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__printVector(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->printVector()"
// params: []
extern "C"
    void casadi__DMatrix__printVector(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__printVector(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->printVector();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printme" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::printme"
// cWrapperName: "casadi__DMatrix__printme"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__printme(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->printme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__printme(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix__printme(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Static method: "quad_form" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::quad_form"
// cWrapperName: "casadi__DMatrix__quad_form"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__quad_form(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1)"
// call: "casadi::DMatrix::quad_form(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CDouble))]
extern "C"
    double casadi__DMatrix__quad_form(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1);
double casadi__DMatrix__quad_form(std::string ** err_msg, casadi::DMatrix* x0, std::vector< double >* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

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


// ================== Normal method: "remove" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::remove"
// cWrapperName: "casadi__DMatrix__remove"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__remove(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->remove(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__remove(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__DMatrix__remove(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->remove(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::repmat"
// cWrapperName: "casadi__DMatrix__repmat__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__repmat__0(std::string ** err_msg, casadi::DMatrix* x0, int x1)"
// call: "casadi::DMatrix::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__repmat__0(std::string ** err_msg, casadi::DMatrix* x0, int x1);
casadi::DMatrix* casadi__DMatrix__repmat__0(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);

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


// ================== Static method: "repmat" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::repmat"
// cWrapperName: "casadi__DMatrix__repmat__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__repmat__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2)"
// call: "casadi::DMatrix::repmat(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__repmat__1(std::string ** err_msg, casadi::DMatrix* x0, int x1, int x2);
casadi::DMatrix* casadi__DMatrix__repmat__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);

        casadi::DMatrix ret = casadi::DMatrix::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;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::repmat"
// cWrapperName: "casadi__DMatrix__repmat__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__repmat__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1)"
// call: "casadi::DMatrix::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__repmat__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::Sparsity* x1);
casadi::DMatrix* casadi__DMatrix__repmat__2(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::DMatrix::repmat(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::repmat"
// cWrapperName: "casadi__DMatrix__repmat__3"
// protoArgs: "(std::string ** err_msg, double* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__repmat__3(std::string ** err_msg, double* x0, casadi::Sparsity* x1)"
// call: "casadi::DMatrix::repmat(x0_, x1_)"
// params: [Ref (Const CDouble),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__repmat__3(std::string ** err_msg, double* x0, casadi::Sparsity* x1);
casadi::DMatrix* casadi__DMatrix__repmat__3(std::string ** err_msg, double* x0, casadi::Sparsity* x1){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

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


// ================== Normal method: "reserve" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::reserve"
// cWrapperName: "casadi__DMatrix__reserve__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__reserve__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__DMatrix__reserve__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
void casadi__DMatrix__reserve__0(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reserve" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::reserve"
// cWrapperName: "casadi__DMatrix__reserve__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__reserve__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->reserve(x0_)"
// params: [CInt]
extern "C"
    void casadi__DMatrix__reserve__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
void casadi__DMatrix__reserve__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->reserve(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "resize" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::resize"
// cWrapperName: "casadi__DMatrix__resize"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__resize(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__DMatrix__resize(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
void casadi__DMatrix__resize(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "row" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::row"
// cWrapperName: "casadi__DMatrix__row__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__row__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->row(x0_)"
// params: [CInt]
extern "C"
    int casadi__DMatrix__row__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
int casadi__DMatrix__row__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "row" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::row"
// cWrapperName: "casadi__DMatrix__row__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__DMatrix__row__1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->row()"
// params: []
extern "C"
    std::vector< int >* casadi__DMatrix__row__1(std::string ** err_msg, casadi::DMatrix* obj);
std::vector< int >* casadi__DMatrix__row__1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sanityCheck"
// cWrapperName: "casadi__DMatrix__sanityCheck__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__sanityCheck__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sanityCheck()"
// params: []
extern "C"
    void casadi__DMatrix__sanityCheck__0(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__sanityCheck__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->sanityCheck();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sanityCheck"
// cWrapperName: "casadi__DMatrix__sanityCheck__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__sanityCheck__1(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
// params: [CBool]
extern "C"
    void casadi__DMatrix__sanityCheck__1(std::string ** err_msg, casadi::DMatrix* obj, int x0);
void casadi__DMatrix__sanityCheck__1(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

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


// ================== Normal method: "set" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::set"
// cWrapperName: "casadi__DMatrix__set__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__set__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)"
// call: "obj->set(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__set__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
void casadi__DMatrix__set__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::set"
// cWrapperName: "casadi__DMatrix__set__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__set__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__DMatrix__set__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1);
void casadi__DMatrix__set__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::set"
// cWrapperName: "casadi__DMatrix__set__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__set__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0)"
// call: "obj->set(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    void casadi__DMatrix__set__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0);
void casadi__DMatrix__set__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::set"
// cWrapperName: "casadi__DMatrix__set__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__set__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [Ref (Const (StdVec CDouble)),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__DMatrix__set__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1);
void casadi__DMatrix__set__3(std::string ** err_msg, casadi::DMatrix* obj, std::vector< double >* x0, int x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::set"
// cWrapperName: "casadi__DMatrix__set__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__set__4(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
// call: "obj->set(x0_)"
// params: [CDouble]
extern "C"
    void casadi__DMatrix__set__4(std::string ** err_msg, casadi::DMatrix* obj, double x0);
void casadi__DMatrix__set__4(std::string ** err_msg, casadi::DMatrix* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::set"
// cWrapperName: "casadi__DMatrix__set__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__set__5(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [CDouble,CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__DMatrix__set__5(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1);
void casadi__DMatrix__set__5(std::string ** err_msg, casadi::DMatrix* obj, double x0, int x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setAll" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setAll"
// cWrapperName: "casadi__DMatrix__setAll"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setAll(std::string ** err_msg, casadi::DMatrix* obj, double* x0)"
// call: "obj->setAll(x0_)"
// params: [Ref (Const CDouble)]
extern "C"
    void casadi__DMatrix__setAll(std::string ** err_msg, casadi::DMatrix* obj, double* x0);
void casadi__DMatrix__setAll(std::string ** err_msg, casadi::DMatrix* obj, double* x0){
    try {
        double x0_ = Marshaling<double,double*>::marshal(x0);

    obj->setAll(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setEqualityCheckingDepth"
// cWrapperName: "casadi__DMatrix__setEqualityCheckingDepth__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setEqualityCheckingDepth__0(std::string ** err_msg)"
// call: "casadi::DMatrix::setEqualityCheckingDepth()"
// params: []
extern "C"
    void casadi__DMatrix__setEqualityCheckingDepth__0(std::string ** err_msg);
void casadi__DMatrix__setEqualityCheckingDepth__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setEqualityCheckingDepth"
// cWrapperName: "casadi__DMatrix__setEqualityCheckingDepth__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::setEqualityCheckingDepth(x0_)"
// params: [CInt]
extern "C"
    void casadi__DMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
void casadi__DMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setMaxNumCallsInPrint"
// cWrapperName: "casadi__DMatrix__setMaxNumCallsInPrint__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setMaxNumCallsInPrint__0(std::string ** err_msg)"
// call: "casadi::DMatrix::setMaxNumCallsInPrint()"
// params: []
extern "C"
    void casadi__DMatrix__setMaxNumCallsInPrint__0(std::string ** err_msg);
void casadi__DMatrix__setMaxNumCallsInPrint__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setMaxNumCallsInPrint"
// cWrapperName: "casadi__DMatrix__setMaxNumCallsInPrint__1"
// protoArgs: "(std::string ** err_msg, long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0)"
// call: "casadi::DMatrix::setMaxNumCallsInPrint(x0_)"
// params: [CLong]
extern "C"
    void casadi__DMatrix__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0);
void casadi__DMatrix__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0){
    try {
        long x0_ = Marshaling<long,long>::marshal(x0);

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


// ================== Normal method: "setNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setNZ"
// cWrapperName: "casadi__DMatrix__setNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__setNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1);
void casadi__DMatrix__setNZ__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::DMatrix* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setNZ"
// cWrapperName: "casadi__DMatrix__setNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__setNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1);
void casadi__DMatrix__setNZ__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::DMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setNZ"
// cWrapperName: "casadi__DMatrix__setNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::DMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__setNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::DMatrix* x1);
void casadi__DMatrix__setNZ__2(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::DMatrix* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setNZ"
// cWrapperName: "casadi__DMatrix__setNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setNZ__3(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::DMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__DMatrix__setNZ__3(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::DMatrix* x1);
void casadi__DMatrix__setNZ__3(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::DMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setPrecision" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setPrecision"
// cWrapperName: "casadi__DMatrix__setPrecision"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setPrecision(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::setPrecision(x0_)"
// params: [CInt]
extern "C"
    void casadi__DMatrix__setPrecision(std::string ** err_msg, int x0);
void casadi__DMatrix__setPrecision(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "setScientific" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setScientific"
// cWrapperName: "casadi__DMatrix__setScientific"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setScientific(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::setScientific(x0_)"
// params: [CBool]
extern "C"
    void casadi__DMatrix__setScientific(std::string ** err_msg, int x0);
void casadi__DMatrix__setScientific(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "setSparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSparse"
// cWrapperName: "casadi__DMatrix__setSparse__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__setSparse__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__setSparse__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__setSparse__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "setSparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSparse"
// cWrapperName: "casadi__DMatrix__setSparse__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__setSparse__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
extern "C"
    casadi::DMatrix* casadi__DMatrix__setSparse__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1);
casadi::DMatrix* casadi__DMatrix__setSparse__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

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


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    void casadi__DMatrix__setSub__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1, int x2);
void casadi__DMatrix__setSub__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Sparsity* x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Const CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__DMatrix__setSub__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2);
void casadi__DMatrix__setSub__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::Slice* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    void casadi__DMatrix__setSub__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, int x2);
void casadi__DMatrix__setSub__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__DMatrix__setSub__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__DMatrix__setSub__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__DMatrix__setSub__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2);
void casadi__DMatrix__setSub__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__DMatrix__setSub__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2);
void casadi__DMatrix__setSub__5(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__6"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__DMatrix__setSub__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2);
void casadi__DMatrix__setSub__6(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, casadi::IMatrix* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__7"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__7(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__DMatrix__setSub__7(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::IMatrix* x2);
void casadi__DMatrix__setSub__7(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::IMatrix* 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);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__8"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__8(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    void casadi__DMatrix__setSub__8(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, int x2);
void casadi__DMatrix__setSub__8(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, int x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__9"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__9(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__setSub__9(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, std::vector< int >* x2);
void casadi__DMatrix__setSub__9(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::IMatrix* x1, std::vector< int >* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__10"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__DMatrix__setSub__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::Slice* x2);
void casadi__DMatrix__setSub__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, casadi::Slice* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__11"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__11(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__DMatrix__setSub__11(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::Slice* x2);
void casadi__DMatrix__setSub__11(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, casadi::Slice* 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);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__12"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__12(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__setSub__12(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, std::vector< int >* x2);
void casadi__DMatrix__setSub__12(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, casadi::Slice* x1, std::vector< int >* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__13"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__13(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__setSub__13(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
void casadi__DMatrix__setSub__13(std::string ** err_msg, casadi::DMatrix* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__14"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__14(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,Ref (Const (StdVec CInt))]
extern "C"
    void casadi__DMatrix__setSub__14(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, std::vector< int >* x2);
void casadi__DMatrix__setSub__14(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, std::vector< int >* x2){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__15"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__15(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec CInt)),CInt]
extern "C"
    void casadi__DMatrix__setSub__15(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, int x2);
void casadi__DMatrix__setSub__15(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, std::vector< int >* x1, 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);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setSub"
// cWrapperName: "casadi__DMatrix__setSub__16"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setSub__16(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt,CInt]
extern "C"
    void casadi__DMatrix__setSub__16(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0, int x1, int x2);
void casadi__DMatrix__setSub__16(std::string ** err_msg, casadi::DMatrix* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setWidth" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setWidth"
// cWrapperName: "casadi__DMatrix__setWidth"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setWidth(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::setWidth(x0_)"
// params: [CInt]
extern "C"
    void casadi__DMatrix__setWidth(std::string ** err_msg, int x0);
void casadi__DMatrix__setWidth(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "setZero" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::setZero"
// cWrapperName: "casadi__DMatrix__setZero"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__setZero(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->setZero()"
// params: []
extern "C"
    void casadi__DMatrix__setZero(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__setZero(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->setZero();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sign" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sign"
// cWrapperName: "casadi__DMatrix__sign"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sign(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sign()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__sign(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__sign(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sin" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sin"
// cWrapperName: "casadi__DMatrix__sin"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sin(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sin()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__sin(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__sin(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sinh" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sinh"
// cWrapperName: "casadi__DMatrix__sinh"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sinh(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sinh()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__sinh(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__sinh(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "size" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::size"
// cWrapperName: "casadi__DMatrix__size__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__size__0(std::string ** err_msg, casadi::DMatrix* obj, int x0)"
// call: "obj->size(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    int casadi__DMatrix__size__0(std::string ** err_msg, casadi::DMatrix* obj, int x0);
int casadi__DMatrix__size__0(std::string ** err_msg, casadi::DMatrix* obj, int x0){
    try {
        casadi::SparsityType x0_ = Marshaling<casadi::SparsityType,int>::marshal(x0);

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


// ================== Normal method: "size" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::size"
// cWrapperName: "casadi__DMatrix__size__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__size__1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->size()"
// params: []
extern "C"
    int casadi__DMatrix__size__1(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__size__1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "size1" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::size1"
// cWrapperName: "casadi__DMatrix__size1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__size1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->size1()"
// params: []
extern "C"
    int casadi__DMatrix__size1(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__size1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "size2" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::size2"
// cWrapperName: "casadi__DMatrix__size2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__size2(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->size2()"
// params: []
extern "C"
    int casadi__DMatrix__size2(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__size2(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sizeD" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sizeD"
// cWrapperName: "casadi__DMatrix__sizeD"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__sizeD(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sizeD()"
// params: []
extern "C"
    int casadi__DMatrix__sizeD(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__sizeD(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sizeL" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sizeL"
// cWrapperName: "casadi__DMatrix__sizeL"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__sizeL(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sizeL()"
// params: []
extern "C"
    int casadi__DMatrix__sizeL(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__sizeL(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sizeU" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sizeU"
// cWrapperName: "casadi__DMatrix__sizeU"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__DMatrix__sizeU(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sizeU()"
// params: []
extern "C"
    int casadi__DMatrix__sizeU(std::string ** err_msg, casadi::DMatrix* obj);
int casadi__DMatrix__sizeU(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Static method: "sparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparse"
// cWrapperName: "casadi__DMatrix__sparse__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sparse__0(std::string ** err_msg)"
// call: "casadi::DMatrix::sparse()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__sparse__0(std::string ** err_msg);
casadi::DMatrix* casadi__DMatrix__sparse__0(std::string ** err_msg){
    try {

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


// ================== Static method: "sparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparse"
// cWrapperName: "casadi__DMatrix__sparse__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sparse__1(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::sparse(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sparse__1(std::string ** err_msg, int x0);
casadi::DMatrix* casadi__DMatrix__sparse__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "sparse" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparse"
// cWrapperName: "casadi__DMatrix__sparse__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sparse__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::DMatrix::sparse(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sparse__2(std::string ** err_msg, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__sparse__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sparsify" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparsify"
// cWrapperName: "casadi__DMatrix__sparsify__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__sparsify__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sparsify()"
// params: []
extern "C"
    void casadi__DMatrix__sparsify__0(std::string ** err_msg, casadi::DMatrix* obj);
void casadi__DMatrix__sparsify__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

    obj->sparsify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sparsify" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparsify"
// cWrapperName: "casadi__DMatrix__sparsify__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DMatrix__sparsify__1(std::string ** err_msg, casadi::DMatrix* obj, double x0)"
// call: "obj->sparsify(x0_)"
// params: [CDouble]
extern "C"
    void casadi__DMatrix__sparsify__1(std::string ** err_msg, casadi::DMatrix* obj, double x0);
void casadi__DMatrix__sparsify__1(std::string ** err_msg, casadi::DMatrix* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->sparsify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sparsity" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparsity"
// cWrapperName: "casadi__DMatrix__sparsity__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__DMatrix__sparsity__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__DMatrix__sparsity__0(std::string ** err_msg, casadi::DMatrix* obj);
casadi::Sparsity* casadi__DMatrix__sparsity__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sparsity" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparsity"
// cWrapperName: "casadi__DMatrix__sparsity__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__DMatrix__sparsity__1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__DMatrix__sparsity__1(std::string ** err_msg, casadi::DMatrix* obj);
casadi::Sparsity* casadi__DMatrix__sparsity__1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparsityRef"
// cWrapperName: "casadi__DMatrix__sparsityRef__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__DMatrix__sparsityRef__0(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__DMatrix__sparsityRef__0(std::string ** err_msg, casadi::DMatrix* obj);
casadi::Sparsity* casadi__DMatrix__sparsityRef__0(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sparsityRef"
// cWrapperName: "casadi__DMatrix__sparsityRef__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__DMatrix__sparsityRef__1(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__DMatrix__sparsityRef__1(std::string ** err_msg, casadi::DMatrix* obj);
casadi::Sparsity* casadi__DMatrix__sparsityRef__1(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sqrt" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sqrt"
// cWrapperName: "casadi__DMatrix__sqrt"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sqrt(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->sqrt()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__sqrt(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__sqrt(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0)"
// call: "obj->sub(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__sub__0(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__1"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1);
casadi::DMatrix* casadi__DMatrix__sub__1(std::string ** err_msg, casadi::DMatrix* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__2(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::DMatrix* casadi__DMatrix__sub__2(std::string ** err_msg, casadi::DMatrix* obj, 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::DMatrix ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__3"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::DMatrix* casadi__DMatrix__sub__3(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__4"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::DMatrix* casadi__DMatrix__sub__4(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__5"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__5(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__5(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::IMatrix* x1);
casadi::DMatrix* casadi__DMatrix__sub__5(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::IMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__6"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__6(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__6(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1);
casadi::DMatrix* casadi__DMatrix__sub__6(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__7"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__7(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__7(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, int x1);
casadi::DMatrix* casadi__DMatrix__sub__7(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__8"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__8(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__8(std::string ** err_msg, casadi::DMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1);
casadi::DMatrix* casadi__DMatrix__sub__8(std::string ** err_msg, casadi::DMatrix* obj, 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);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__9"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__9(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__9(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::Slice* x1);
casadi::DMatrix* casadi__DMatrix__sub__9(std::string ** err_msg, casadi::DMatrix* obj, int x0, casadi::Slice* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__10"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, int x1);
casadi::DMatrix* casadi__DMatrix__sub__10(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, int x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__11"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__11(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__11(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::DMatrix* casadi__DMatrix__sub__11(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__12"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__12(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__12(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::Slice* x1);
casadi::DMatrix* casadi__DMatrix__sub__12(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, casadi::Slice* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__13"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__13(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__13(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, std::vector< int >* x1);
casadi::DMatrix* casadi__DMatrix__sub__13(std::string ** err_msg, casadi::DMatrix* obj, casadi::Slice* x0, std::vector< int >* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__14"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__14(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__14(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
casadi::DMatrix* casadi__DMatrix__sub__14(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__15"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__15(std::string ** err_msg, casadi::DMatrix* obj, int x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (StdVec CInt))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__15(std::string ** err_msg, casadi::DMatrix* obj, int x0, std::vector< int >* x1);
casadi::DMatrix* casadi__DMatrix__sub__15(std::string ** err_msg, casadi::DMatrix* obj, int x0, std::vector< int >* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__16"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__16(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__16(std::string ** err_msg, casadi::DMatrix* obj, std::vector< int >* x0, int x1);
casadi::DMatrix* casadi__DMatrix__sub__16(std::string ** err_msg, casadi::DMatrix* obj, 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);

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


// ================== Normal method: "sub" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sub"
// cWrapperName: "casadi__DMatrix__sub__17"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sub__17(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sub__17(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__sub__17(std::string ** err_msg, casadi::DMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::DMatrix* >* >* casadi__DMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// call: "casadi::DMatrix::sym(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::DMatrix* >* >* casadi__DMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< casadi::DMatrix* >* >* casadi__DMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

        std::vector< std::vector< casadi::DMatrix > > ret = casadi::DMatrix::sym(x0_, x1_, x2_, x3_, x4_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__1"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))
// cWrapperRetType: "std::vector< std::vector< casadi::DMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::DMatrix* >* >* casadi__DMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// call: "casadi::DMatrix::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::DMatrix* >* >* casadi__DMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< casadi::DMatrix* >* >* casadi__DMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< std::vector< casadi::DMatrix > > ret = casadi::DMatrix::sym(x0_, x1_, x2_, x3_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__2"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* casadi__DMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// call: "casadi::DMatrix::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CInt,CInt]
extern "C"
    std::vector< casadi::DMatrix* >* casadi__DMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
std::vector< casadi::DMatrix* >* casadi__DMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< casadi::DMatrix > ret = casadi::DMatrix::sym(x0_, x1_, x2_, x3_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__3"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* casadi__DMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// call: "casadi::DMatrix::sym(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    std::vector< casadi::DMatrix* >* casadi__DMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
std::vector< casadi::DMatrix* >* casadi__DMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< casadi::DMatrix > ret = casadi::DMatrix::sym(x0_, x1_, x2_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__4"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// call: "casadi::DMatrix::sym(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
casadi::DMatrix* casadi__DMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

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


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__5"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sym__5(std::string ** err_msg, std::string* x0)"
// call: "casadi::DMatrix::sym(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sym__5(std::string ** err_msg, std::string* x0);
casadi::DMatrix* casadi__DMatrix__sym__5(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Static method: "sym" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::sym"
// cWrapperName: "casadi__DMatrix__sym__6"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__sym__6(std::string ** err_msg, std::string* x0, int x1)"
// call: "casadi::DMatrix::sym(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__sym__6(std::string ** err_msg, std::string* x0, int x1);
casadi::DMatrix* casadi__DMatrix__sym__6(std::string ** err_msg, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


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

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


// ================== Normal method: "tan" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::tan"
// cWrapperName: "casadi__DMatrix__tan"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__tan(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->tan()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__tan(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__tan(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "tanh" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::tanh"
// cWrapperName: "casadi__DMatrix__tanh"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__tanh(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->tanh()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__tanh(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__tanh(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "toScalar" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::toScalar"
// cWrapperName: "casadi__DMatrix__toScalar"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: Const CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__toScalar(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->toScalar()"
// params: []
extern "C"
    double casadi__DMatrix__toScalar(std::string ** err_msg, casadi::DMatrix* obj);
double casadi__DMatrix__toScalar(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Normal method: "trans" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::trans"
// cWrapperName: "casadi__DMatrix__trans"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__trans(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->trans()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__trans(std::string ** err_msg, casadi::DMatrix* obj);
casadi::DMatrix* casadi__DMatrix__trans(std::string ** err_msg, casadi::DMatrix* obj){
    try {

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


// ================== Static method: "triplet" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::triplet"
// cWrapperName: "casadi__DMatrix__triplet__0"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4)"
// call: "casadi::DMatrix::triplet(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (StdVec CDouble)),CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4);
casadi::DMatrix* casadi__DMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

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


// ================== Static method: "triplet" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::triplet"
// cWrapperName: "casadi__DMatrix__triplet__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2)"
// call: "casadi::DMatrix::triplet(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (StdVec CDouble))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2);
casadi::DMatrix* casadi__DMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

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


// ================== Static method: "unary" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::unary"
// cWrapperName: "casadi__DMatrix__unary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__unary(std::string ** err_msg, int x0, casadi::DMatrix* x1)"
// call: "casadi::DMatrix::unary(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__unary(std::string ** err_msg, int x0, casadi::DMatrix* x1);
casadi::DMatrix* casadi__DMatrix__unary(std::string ** err_msg, int x0, casadi::DMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

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


// ================== Static method: "zeros" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::zeros"
// cWrapperName: "casadi__DMatrix__zeros__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__zeros__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::DMatrix::zeros(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::DMatrix* casadi__DMatrix__zeros__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::DMatrix* casadi__DMatrix__zeros__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Static method: "zeros" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::zeros"
// cWrapperName: "casadi__DMatrix__zeros__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__zeros__1(std::string ** err_msg)"
// call: "casadi::DMatrix::zeros()"
// params: []
extern "C"
    casadi::DMatrix* casadi__DMatrix__zeros__1(std::string ** err_msg);
casadi::DMatrix* casadi__DMatrix__zeros__1(std::string ** err_msg){
    try {

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


// ================== Static method: "zeros" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::zeros"
// cWrapperName: "casadi__DMatrix__zeros__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__zeros__2(std::string ** err_msg, int x0)"
// call: "casadi::DMatrix::zeros(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__zeros__2(std::string ** err_msg, int x0);
casadi::DMatrix* casadi__DMatrix__zeros__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "zeros" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::zeros"
// cWrapperName: "casadi__DMatrix__zeros__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__DMatrix__zeros__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::DMatrix::zeros(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::DMatrix* casadi__DMatrix__zeros__3(std::string ** err_msg, int x0, int x1);
casadi::DMatrix* casadi__DMatrix__zeros__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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



// ================== delete UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")===============
// classType: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")
extern "C"
    void delete_casadi__DerivativeGenerator(casadi::DerivativeGenerator* obj);
void delete_casadi__DerivativeGenerator(casadi::DerivativeGenerator* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DerivativeGenerator"
// cppName: "casadi::DerivativeGenerator"
// cWrapperName: "casadi__DerivativeGenerator__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")
// cWrapperRetType: "casadi::DerivativeGenerator*"
// proto: "casadi::DerivativeGenerator* casadi__DerivativeGenerator__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::DerivativeGenerator()"
// params: []
extern "C"
    casadi::DerivativeGenerator* casadi__DerivativeGenerator__CONSTRUCTOR(std::string ** err_msg);
casadi::DerivativeGenerator* casadi__DerivativeGenerator__CONSTRUCTOR(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "ExternalFunction")===============
// classType: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
extern "C"
    void delete_casadi__ExternalFunction(casadi::ExternalFunction* obj);
void delete_casadi__ExternalFunction(casadi::ExternalFunction* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ExternalFunction"
// cppName: "casadi::ExternalFunction"
// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
// cWrapperRetType: "casadi::ExternalFunction*"
// proto: "casadi::ExternalFunction* casadi__ExternalFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0)"
// call: "casadi::ExternalFunction(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::ExternalFunction* casadi__ExternalFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0);
casadi::ExternalFunction* casadi__ExternalFunction__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::ExternalFunction"
// cppName: "casadi::ExternalFunction"
// cWrapperName: "casadi__ExternalFunction__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "ExternalFunction")
// cWrapperRetType: "casadi::ExternalFunction*"
// proto: "casadi::ExternalFunction* casadi__ExternalFunction__CONSTRUCTOR__1(std::string ** err_msg)"
// call: "casadi::ExternalFunction()"
// params: []
extern "C"
    casadi::ExternalFunction* casadi__ExternalFunction__CONSTRUCTOR__1(std::string ** err_msg);
casadi::ExternalFunction* casadi__ExternalFunction__CONSTRUCTOR__1(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "Function")===============
// classType: UserType (Namespace ["casadi"]) (Name "Function")
extern "C"
    void delete_casadi__Function(casadi::Function* obj);
void delete_casadi__Function(casadi::Function* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Function"
// cppName: "casadi::Function"
// cWrapperName: "casadi__Function__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::Function()"
// params: []
extern "C"
    casadi::Function* casadi__Function__CONSTRUCTOR(std::string ** err_msg);
casadi::Function* casadi__Function__CONSTRUCTOR(std::string ** err_msg){
    try {

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


// ================== Normal method: "addMonitor" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::addMonitor"
// cWrapperName: "casadi__Function__addMonitor"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->addMonitor(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0);
void casadi__Function__addMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->addMonitor(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
// args: "(x0_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0)"
// call: "obj->call(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
extern "C"
    std::vector< casadi::MX* >* casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0);
std::vector< casadi::MX* >* casadi__Function__call__0(std::string ** err_msg, casadi::Function* obj, 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 = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1)"
// call: "obj->call(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
extern "C"
    std::vector< casadi::MX* >* casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1);
std::vector< casadi::MX* >* casadi__Function__call__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        std::vector< casadi::MX > ret = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2)"
// call: "obj->call(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
extern "C"
    std::vector< casadi::MX* >* casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2);
std::vector< casadi::MX* >* casadi__Function__call__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, int x1, int x2){
    try {
        std::vector< casadi::MX > x0_ = Marshaling<std::vector< casadi::MX >,std::vector< casadi::MX* >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        std::vector< casadi::MX > ret = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0)"
// args: "(x0_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0)"
// call: "obj->call(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
extern "C"
    std::vector< casadi::SX* >* casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0);
std::vector< casadi::SX* >* casadi__Function__call__3(std::string ** err_msg, casadi::Function* obj, 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 = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1)"
// call: "obj->call(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
extern "C"
    std::vector< casadi::SX* >* casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1);
std::vector< casadi::SX* >* casadi__Function__call__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        std::vector< casadi::SX > ret = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2)"
// call: "obj->call(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
extern "C"
    std::vector< casadi::SX* >* casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2);
std::vector< casadi::SX* >* casadi__Function__call__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, int x1, int x2){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        std::vector< casadi::SX > ret = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0)"
// args: "(x0_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0)"
// call: "obj->call(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
extern "C"
    std::vector< casadi::DMatrix* >* casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0);
std::vector< casadi::DMatrix* >* casadi__Function__call__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);

        std::vector< casadi::DMatrix > ret = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__7"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1)"
// call: "obj->call(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
extern "C"
    std::vector< casadi::DMatrix* >* casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1);
std::vector< casadi::DMatrix* >* casadi__Function__call__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        std::vector< casadi::DMatrix > ret = obj->call(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;
    }
}


// ================== Normal method: "call" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::call"
// cWrapperName: "casadi__Function__call__8"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "std::vector< casadi::DMatrix* >*"
// proto: "std::vector< casadi::DMatrix* >* casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2)"
// call: "obj->call(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
extern "C"
    std::vector< casadi::DMatrix* >* casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2);
std::vector< casadi::DMatrix* >* casadi__Function__call__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, int x1, int x2){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        std::vector< casadi::DMatrix > ret = obj->call(x0_, x1_, x2_);
        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;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
extern "C"
    void casadi__Function__callDerivative__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5);
void casadi__Function__callDerivative__0(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5){
    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< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::MX > > x5_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x5);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool]
extern "C"
    void casadi__Function__callDerivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6);
void casadi__Function__callDerivative__1(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6){
    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< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::MX > > x5_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x5);
        bool x6_ = Marshaling<bool,int>::marshal(x6);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),CBool,CBool]
extern "C"
    void casadi__Function__callDerivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7);
void casadi__Function__callDerivative__2(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1, std::vector< std::vector< casadi::MX* >* >* x2, std::vector< std::vector< casadi::MX* >* >* x3, std::vector< std::vector< casadi::MX* >* >* x4, std::vector< std::vector< casadi::MX* >* >* x5, int x6, int x7){
    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< std::vector< casadi::MX > > x2_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::MX > > x3_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::MX > > x4_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::MX > > x5_ = Marshaling<std::vector< std::vector< casadi::MX > >,std::vector< std::vector< casadi::MX* >* >*>::marshal(x5);
        bool x6_ = Marshaling<bool,int>::marshal(x6);
        bool x7_ = Marshaling<bool,int>::marshal(x7);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
extern "C"
    void casadi__Function__callDerivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5);
void casadi__Function__callDerivative__3(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5){
    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< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::SX > > x5_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x5);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool]
extern "C"
    void casadi__Function__callDerivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6);
void casadi__Function__callDerivative__4(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6){
    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< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::SX > > x5_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x5);
        bool x6_ = Marshaling<bool,int>::marshal(x6);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),CBool,CBool]
extern "C"
    void casadi__Function__callDerivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7);
void casadi__Function__callDerivative__5(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1, std::vector< std::vector< casadi::SX* >* >* x2, std::vector< std::vector< casadi::SX* >* >* x3, std::vector< std::vector< casadi::SX* >* >* x4, std::vector< std::vector< casadi::SX* >* >* x5, int x6, int x7){
    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< std::vector< casadi::SX > > x2_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::SX > > x3_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::SX > > x4_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::SX > > x5_ = Marshaling<std::vector< std::vector< casadi::SX > >,std::vector< std::vector< casadi::SX* >* >*>::marshal(x5);
        bool x6_ = Marshaling<bool,int>::marshal(x6);
        bool x7_ = Marshaling<bool,int>::marshal(x7);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))]
extern "C"
    void casadi__Function__callDerivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5);
void casadi__Function__callDerivative__6(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::DMatrix > > x4_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::DMatrix > > x5_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x5);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__7"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool]
extern "C"
    void casadi__Function__callDerivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6);
void casadi__Function__callDerivative__7(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::DMatrix > > x4_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::DMatrix > > x5_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x5);
        bool x6_ = Marshaling<bool,int>::marshal(x6);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callDerivative"
// cWrapperName: "casadi__Function__callDerivative__8"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__callDerivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix"))))),Ref (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "DMatrix")))),CBool,CBool]
extern "C"
    void casadi__Function__callDerivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7);
void casadi__Function__callDerivative__8(std::string ** err_msg, casadi::Function* obj, std::vector< casadi::DMatrix* >* x0, std::vector< casadi::DMatrix* >* x1, std::vector< std::vector< casadi::DMatrix* >* >* x2, std::vector< std::vector< casadi::DMatrix* >* >* x3, std::vector< std::vector< casadi::DMatrix* >* >* x4, std::vector< std::vector< casadi::DMatrix* >* >* x5, int x6, int x7){
    try {
        std::vector< casadi::DMatrix > x0_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x0);
        std::vector< casadi::DMatrix > x1_ = Marshaling<std::vector< casadi::DMatrix >,std::vector< casadi::DMatrix* >*>::marshal(x1);
        std::vector< std::vector< casadi::DMatrix > > x2_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x2);
        std::vector< std::vector< casadi::DMatrix > > x3_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x3);
        std::vector< std::vector< casadi::DMatrix > > x4_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x4);
        std::vector< std::vector< casadi::DMatrix > > x5_ = Marshaling<std::vector< std::vector< casadi::DMatrix > >,std::vector< std::vector< casadi::DMatrix* >* >*>::marshal(x5);
        bool x6_ = Marshaling<bool,int>::marshal(x6);
        bool x7_ = Marshaling<bool,int>::marshal(x7);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "callParallel" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::callParallel"
// cWrapperName: "casadi__Function__callParallel"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0)"
// args: "(x0_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* casadi__Function__callParallel(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0)"
// call: "obj->callParallel(x0_)"
// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))))]
extern "C"
    std::vector< std::vector< casadi::MX* >* >* casadi__Function__callParallel(std::string ** err_msg, casadi::Function* obj, std::vector< std::vector< casadi::MX* >* >* x0);
std::vector< std::vector< casadi::MX* >* >* casadi__Function__callParallel(std::string ** err_msg, casadi::Function* obj, 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);

        std::vector< std::vector< casadi::MX > > ret = obj->callParallel(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;
    }
}


// ================== Normal method: "checkInputs" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::checkInputs"
// cWrapperName: "casadi__Function__checkInputs"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->checkInputs()"
// params: []
extern "C"
    void casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj);
void casadi__Function__checkInputs(std::string ** err_msg, casadi::Function* obj){
    try {

    obj->checkInputs();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "derivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::derivative"
// cWrapperName: "casadi__Function__derivative"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__derivative(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// call: "obj->derivative(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Function* casadi__Function__derivative(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
casadi::Function* casadi__Function__derivative(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "evaluate" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::evaluate"
// cWrapperName: "casadi__Function__evaluate"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__evaluate(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->evaluate()"
// params: []
extern "C"
    void casadi__Function__evaluate(std::string ** err_msg, casadi::Function* obj);
void casadi__Function__evaluate(std::string ** err_msg, casadi::Function* obj){
    try {

    obj->evaluate();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "fullJacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::fullJacobian"
// cWrapperName: "casadi__Function__fullJacobian"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->fullJacobian()"
// params: []
extern "C"
    casadi::Function* casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj);
casadi::Function* casadi__Function__fullJacobian(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "generateCode" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::generateCode"
// cWrapperName: "casadi__Function__generateCode__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Function__generateCode__0(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->generateCode()"
// params: []
extern "C"
    std::string* casadi__Function__generateCode__0(std::string ** err_msg, casadi::Function* obj);
std::string* casadi__Function__generateCode__0(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "generateCode" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::generateCode"
// cWrapperName: "casadi__Function__generateCode__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__generateCode__1(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->generateCode(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__Function__generateCode__1(std::string ** err_msg, casadi::Function* obj, std::string* x0);
void casadi__Function__generateCode__1(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->generateCode(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getInputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getInputScheme"
// cWrapperName: "casadi__Function__getInputScheme"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__Function__getInputScheme(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getInputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__Function__getInputScheme(std::string ** err_msg, casadi::Function* obj);
casadi::IOScheme* casadi__Function__getInputScheme(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getNumInputElements" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getNumInputElements"
// cWrapperName: "casadi__Function__getNumInputElements"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Function__getNumInputElements(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getNumInputElements()"
// params: []
extern "C"
    int casadi__Function__getNumInputElements(std::string ** err_msg, casadi::Function* obj);
int casadi__Function__getNumInputElements(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getNumInputNonzeros" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getNumInputNonzeros"
// cWrapperName: "casadi__Function__getNumInputNonzeros"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Function__getNumInputNonzeros(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getNumInputNonzeros()"
// params: []
extern "C"
    int casadi__Function__getNumInputNonzeros(std::string ** err_msg, casadi::Function* obj);
int casadi__Function__getNumInputNonzeros(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getNumOutputElements" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getNumOutputElements"
// cWrapperName: "casadi__Function__getNumOutputElements"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Function__getNumOutputElements(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getNumOutputElements()"
// params: []
extern "C"
    int casadi__Function__getNumOutputElements(std::string ** err_msg, casadi::Function* obj);
int casadi__Function__getNumOutputElements(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getNumOutputNonzeros" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getNumOutputNonzeros"
// cWrapperName: "casadi__Function__getNumOutputNonzeros"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Function__getNumOutputNonzeros(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getNumOutputNonzeros()"
// params: []
extern "C"
    int casadi__Function__getNumOutputNonzeros(std::string ** err_msg, casadi::Function* obj);
int casadi__Function__getNumOutputNonzeros(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getOutputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getOutputScheme"
// cWrapperName: "casadi__Function__getOutputScheme"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__Function__getOutputScheme(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getOutputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__Function__getOutputScheme(std::string ** err_msg, casadi::Function* obj);
casadi::IOScheme* casadi__Function__getOutputScheme(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getSanitizedName" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getSanitizedName"
// cWrapperName: "casadi__Function__getSanitizedName"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Function__getSanitizedName(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->getSanitizedName()"
// params: []
extern "C"
    std::string* casadi__Function__getSanitizedName(std::string ** err_msg, casadi::Function* obj);
std::string* casadi__Function__getSanitizedName(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "getStat" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::getStat"
// cWrapperName: "casadi__Function__getStat"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__Function__getStat(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->getStat(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::GenericType* casadi__Function__getStat(std::string ** err_msg, casadi::Function* obj, std::string* x0);
casadi::GenericType* casadi__Function__getStat(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->gradient(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
casadi::Function* casadi__Function__gradient__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// call: "obj->gradient(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
casadi::Function* casadi__Function__gradient__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->gradient(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
casadi::Function* casadi__Function__gradient__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// call: "obj->gradient(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::Function* casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
casadi::Function* casadi__Function__gradient__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->gradient()"
// params: []
extern "C"
    casadi::Function* casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj);
casadi::Function* casadi__Function__gradient__4(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->gradient(x0_)"
// params: [CInt]
extern "C"
    casadi::Function* casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0);
casadi::Function* casadi__Function__gradient__5(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "gradient" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::gradient"
// cWrapperName: "casadi__Function__gradient__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// call: "obj->gradient(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Function* casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
casadi::Function* casadi__Function__gradient__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->hessian(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
casadi::Function* casadi__Function__hessian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// call: "obj->hessian(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
casadi::Function* casadi__Function__hessian__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->hessian(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
casadi::Function* casadi__Function__hessian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// call: "obj->hessian(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::Function* casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
casadi::Function* casadi__Function__hessian__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->hessian()"
// params: []
extern "C"
    casadi::Function* casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj);
casadi::Function* casadi__Function__hessian__4(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->hessian(x0_)"
// params: [CInt]
extern "C"
    casadi::Function* casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0);
casadi::Function* casadi__Function__hessian__5(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "hessian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::hessian"
// cWrapperName: "casadi__Function__hessian__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// call: "obj->hessian(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Function* casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
casadi::Function* casadi__Function__hessian__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "inputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::inputScheme"
// cWrapperName: "casadi__Function__inputScheme__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__Function__inputScheme__0(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->inputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__Function__inputScheme__0(std::string ** err_msg, casadi::Function* obj);
casadi::IOScheme* casadi__Function__inputScheme__0(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "inputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::inputScheme"
// cWrapperName: "casadi__Function__inputScheme__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IOScheme"))
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__Function__inputScheme__1(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->inputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__Function__inputScheme__1(std::string ** err_msg, casadi::Function* obj);
casadi::IOScheme* casadi__Function__inputScheme__1(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->jacSparsity(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
casadi::Sparsity* casadi__Function__jacSparsity__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
casadi::Sparsity* casadi__Function__jacSparsity__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
casadi::Sparsity* casadi__Function__jacSparsity__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// call: "obj->jacSparsity(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
casadi::Sparsity* casadi__Function__jacSparsity__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
// params: [CInt,Ref (Const StdString),CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2);
casadi::Sparsity* casadi__Function__jacSparsity__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
// params: [CInt,Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3);
casadi::Sparsity* casadi__Function__jacSparsity__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__6(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->jacSparsity(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__6(std::string ** err_msg, casadi::Function* obj, std::string* x0);
casadi::Sparsity* casadi__Function__jacSparsity__6(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__7"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// call: "obj->jacSparsity(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
casadi::Sparsity* casadi__Function__jacSparsity__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__8"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CInt,CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2);
casadi::Sparsity* casadi__Function__jacSparsity__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__9"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3);
casadi::Sparsity* casadi__Function__jacSparsity__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__10"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__10(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->jacSparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__10(std::string ** err_msg, casadi::Function* obj);
casadi::Sparsity* casadi__Function__jacSparsity__10(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__11"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__11(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->jacSparsity(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__11(std::string ** err_msg, casadi::Function* obj, int x0);
casadi::Sparsity* casadi__Function__jacSparsity__11(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__12"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// call: "obj->jacSparsity(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
casadi::Sparsity* casadi__Function__jacSparsity__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__13"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
// params: [CInt,CInt,CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2);
casadi::Sparsity* casadi__Function__jacSparsity__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacSparsity"
// cWrapperName: "casadi__Function__jacSparsity__14"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Function__jacSparsity__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Function__jacSparsity__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3);
casadi::Sparsity* casadi__Function__jacSparsity__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->jacobian(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
casadi::Function* casadi__Function__jacobian__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2);
casadi::Function* casadi__Function__jacobian__1(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
casadi::Function* casadi__Function__jacobian__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// call: "obj->jacobian(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
casadi::Function* casadi__Function__jacobian__3(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
// params: [CInt,Ref (Const StdString),CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2);
casadi::Function* casadi__Function__jacobian__4(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
// params: [CInt,Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3);
casadi::Function* casadi__Function__jacobian__5(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->jacobian(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0);
casadi::Function* casadi__Function__jacobian__6(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__7"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// call: "obj->jacobian(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::Function* casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
casadi::Function* casadi__Function__jacobian__7(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__8"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CInt,CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2);
casadi::Function* casadi__Function__jacobian__8(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__9"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CBool,CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3);
casadi::Function* casadi__Function__jacobian__9(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__10"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->jacobian()"
// params: []
extern "C"
    casadi::Function* casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj);
casadi::Function* casadi__Function__jacobian__10(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__11"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->jacobian(x0_)"
// params: [CInt]
extern "C"
    casadi::Function* casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0);
casadi::Function* casadi__Function__jacobian__11(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__12"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// call: "obj->jacobian(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Function* casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
casadi::Function* casadi__Function__jacobian__12(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__13"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
// params: [CInt,CInt,CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2);
casadi::Function* casadi__Function__jacobian__13(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "jacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::jacobian"
// cWrapperName: "casadi__Function__jacobian__14"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,CBool,CBool]
extern "C"
    casadi::Function* casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3);
casadi::Function* casadi__Function__jacobian__14(std::string ** err_msg, casadi::Function* obj, int x0, int x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "outputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::outputScheme"
// cWrapperName: "casadi__Function__outputScheme__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__Function__outputScheme__0(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->outputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__Function__outputScheme__0(std::string ** err_msg, casadi::Function* obj);
casadi::IOScheme* casadi__Function__outputScheme__0(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "outputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::outputScheme"
// cWrapperName: "casadi__Function__outputScheme__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IOScheme"))
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__Function__outputScheme__1(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->outputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__Function__outputScheme__1(std::string ** err_msg, casadi::Function* obj);
casadi::IOScheme* casadi__Function__outputScheme__1(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "removeMonitor" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::removeMonitor"
// cWrapperName: "casadi__Function__removeMonitor"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->removeMonitor(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0);
void casadi__Function__removeMonitor(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->removeMonitor(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setDerivative" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setDerivative"
// cWrapperName: "casadi__Function__setDerivative"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setDerivative(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
// call: "obj->setDerivative(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,CInt]
extern "C"
    void casadi__Function__setDerivative(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2);
void casadi__Function__setDerivative(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setDerivative(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setFullJacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setFullJacobian"
// cWrapperName: "casadi__Function__setFullJacobian"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
// call: "obj->setFullJacobian(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    void casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0);
void casadi__Function__setFullJacobian(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);

    obj->setFullJacobian(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setInputScheme"
// cWrapperName: "casadi__Function__setInputScheme"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setInputScheme(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0)"
// call: "obj->setInputScheme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IOScheme")))]
extern "C"
    void casadi__Function__setInputScheme(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0);
void casadi__Function__setInputScheme(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0){
    try {
        casadi::IOScheme x0_ = Marshaling<casadi::IOScheme,casadi::IOScheme*>::marshal(x0);

    obj->setInputScheme(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    void casadi__Function__setJacSparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2);
void casadi__Function__setJacSparsity__0(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),Ref (Const StdString),CBool]
extern "C"
    void casadi__Function__setJacSparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3);
void casadi__Function__setJacSparsity__1(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, std::string* x2, int x3){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,Ref (Const StdString)]
extern "C"
    void casadi__Function__setJacSparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2);
void casadi__Function__setJacSparsity__2(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,Ref (Const StdString),CBool]
extern "C"
    void casadi__Function__setJacSparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3);
void casadi__Function__setJacSparsity__3(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, std::string* x2, int x3){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),CInt]
extern "C"
    void casadi__Function__setJacSparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2);
void casadi__Function__setJacSparsity__4(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const StdString),CInt,CBool]
extern "C"
    void casadi__Function__setJacSparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3);
void casadi__Function__setJacSparsity__5(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, std::string* x1, int x2, int x3){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
extern "C"
    void casadi__Function__setJacSparsity__6(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2);
void casadi__Function__setJacSparsity__6(std::string ** err_msg, casadi::Function* obj, 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);

    obj->setJacSparsity(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacSparsity" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacSparsity"
// cWrapperName: "casadi__Function__setJacSparsity__7"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacSparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt,CBool]
extern "C"
    void casadi__Function__setJacSparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3);
void casadi__Function__setJacSparsity__7(std::string ** err_msg, casadi::Function* obj, casadi::Sparsity* x0, int x1, int x2, int x3){
    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);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "setJacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacobian"
// cWrapperName: "casadi__Function__setJacobian__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0)"
// call: "obj->setJacobian(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    void casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0);
void casadi__Function__setJacobian__0(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);

    obj->setJacobian(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacobian"
// cWrapperName: "casadi__Function__setJacobian__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1)"
// call: "obj->setJacobian(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt]
extern "C"
    void casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1);
void casadi__Function__setJacobian__1(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setJacobian(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacobian"
// cWrapperName: "casadi__Function__setJacobian__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2)"
// call: "obj->setJacobian(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,CInt]
extern "C"
    void casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2);
void casadi__Function__setJacobian__2(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setJacobian(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setJacobian" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setJacobian"
// cWrapperName: "casadi__Function__setJacobian__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3)"
// call: "obj->setJacobian(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),CInt,CInt,CBool]
extern "C"
    void casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3);
void casadi__Function__setJacobian__3(std::string ** err_msg, casadi::Function* obj, casadi::Function* x0, int x1, int x2, int x3){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

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


// ================== Normal method: "setOutputScheme" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::setOutputScheme"
// cWrapperName: "casadi__Function__setOutputScheme"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__setOutputScheme(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0)"
// call: "obj->setOutputScheme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IOScheme")))]
extern "C"
    void casadi__Function__setOutputScheme(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0);
void casadi__Function__setOutputScheme(std::string ** err_msg, casadi::Function* obj, casadi::IOScheme* x0){
    try {
        casadi::IOScheme x0_ = Marshaling<casadi::IOScheme,casadi::IOScheme*>::marshal(x0);

    obj->setOutputScheme(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "spCanEvaluate" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::spCanEvaluate"
// cWrapperName: "casadi__Function__spCanEvaluate"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->spCanEvaluate(x0_)"
// params: [CBool]
extern "C"
    int casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0);
int casadi__Function__spCanEvaluate(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "spEvaluate" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::spEvaluate"
// cWrapperName: "casadi__Function__spEvaluate"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__spEvaluate(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->spEvaluate(x0_)"
// params: [CBool]
extern "C"
    void casadi__Function__spEvaluate(std::string ** err_msg, casadi::Function* obj, int x0);
void casadi__Function__spEvaluate(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->spEvaluate(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "spInit" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::spInit"
// cWrapperName: "casadi__Function__spInit"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__spInit(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->spInit(x0_)"
// params: [CBool]
extern "C"
    void casadi__Function__spInit(std::string ** err_msg, casadi::Function* obj, int x0);
void casadi__Function__spInit(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->spInit(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "symbolicInput" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::symbolicInput"
// cWrapperName: "casadi__Function__symbolicInput"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__Function__symbolicInput(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->symbolicInput()"
// params: []
extern "C"
    std::vector< casadi::MX* >* casadi__Function__symbolicInput(std::string ** err_msg, casadi::Function* obj);
std::vector< casadi::MX* >* casadi__Function__symbolicInput(std::string ** err_msg, casadi::Function* obj){
    try {

        std::vector< casadi::MX > ret = obj->symbolicInput();
        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;
    }
}


// ================== Normal method: "symbolicInputSX" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::symbolicInputSX"
// cWrapperName: "casadi__Function__symbolicInputSX"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__Function__symbolicInputSX(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->symbolicInputSX()"
// params: []
extern "C"
    std::vector< casadi::SX* >* casadi__Function__symbolicInputSX(std::string ** err_msg, casadi::Function* obj);
std::vector< casadi::SX* >* casadi__Function__symbolicInputSX(std::string ** err_msg, casadi::Function* obj){
    try {

        std::vector< casadi::SX > ret = obj->symbolicInputSX();
        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;
    }
}


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__0"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->tangent(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1);
casadi::Function* casadi__Function__tangent__0(std::string ** err_msg, casadi::Function* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1)"
// call: "obj->tangent(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1);
casadi::Function* casadi__Function__tangent__1(std::string ** err_msg, casadi::Function* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0)"
// call: "obj->tangent(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::Function* casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0);
casadi::Function* casadi__Function__tangent__2(std::string ** err_msg, casadi::Function* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// call: "obj->tangent(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::Function* casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
casadi::Function* casadi__Function__tangent__3(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__4"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj)"
// call: "obj->tangent()"
// params: []
extern "C"
    casadi::Function* casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj);
casadi::Function* casadi__Function__tangent__4(std::string ** err_msg, casadi::Function* obj){
    try {

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


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__5"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0)"
// call: "obj->tangent(x0_)"
// params: [CInt]
extern "C"
    casadi::Function* casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0);
casadi::Function* casadi__Function__tangent__5(std::string ** err_msg, casadi::Function* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "tangent" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::tangent"
// cWrapperName: "casadi__Function__tangent__6"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1)"
// call: "obj->tangent(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Function* casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1);
casadi::Function* casadi__Function__tangent__6(std::string ** err_msg, casadi::Function* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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



// ================== delete UserType (Namespace ["casadi"]) (Name "Functor")===============
// classType: UserType (Namespace ["casadi"]) (Name "Functor")
extern "C"
    void delete_casadi__Functor(casadi::Functor* obj);
void delete_casadi__Functor(casadi::Functor* obj){
    delete obj;
}


// ================== delete UserType (Namespace ["casadi"]) (Name "GenericType")===============
// classType: UserType (Namespace ["casadi"]) (Name "GenericType")
extern "C"
    void delete_casadi__GenericType(casadi::GenericType* obj);
void delete_casadi__GenericType(casadi::GenericType* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::Callback* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, casadi::Callback* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Callback")))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, casadi::Callback* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__0(std::string ** err_msg, casadi::Callback* x0){
    try {
        casadi::Callback x0_ = Marshaling<casadi::Callback,casadi::Callback*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::DerivativeGenerator* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::DerivativeGenerator* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DerivativeGenerator")))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::DerivativeGenerator* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__1(std::string ** err_msg, casadi::DerivativeGenerator* x0){
    try {
        casadi::DerivativeGenerator x0_ = Marshaling<casadi::DerivativeGenerator,casadi::DerivativeGenerator*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, casadi::SharedObject* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SharedObject")))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, casadi::SharedObject* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__2(std::string ** err_msg, casadi::SharedObject* x0){
    try {
        casadi::SharedObject x0_ = Marshaling<casadi::SharedObject,casadi::SharedObject*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__3(std::string ** err_msg, casadi::Function* x0){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, std::vector< std::string* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::string* >* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (StdVec StdString))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::string* >* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__4(std::string ** err_msg, std::vector< std::string* >* x0){
    try {
        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< double >* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__5(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__6"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< int >* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__6(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__7"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const (StdVec CBool))]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::vector< int >* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__7(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< bool > x0_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__8"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0)"
// call: "casadi::GenericType(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__9"
// protoArgs: "(std::string ** err_msg, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, double x0)"
// call: "casadi::GenericType(x0_)"
// params: [CDouble]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, double x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__9(std::string ** err_msg, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__10"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, int x0)"
// call: "casadi::GenericType(x0_)"
// params: [CInt]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, int x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__10(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__11"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg, int x0)"
// call: "casadi::GenericType(x0_)"
// params: [CBool]
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg, int x0);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__11(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType"
// cWrapperName: "casadi__GenericType__CONSTRUCTOR__12"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__CONSTRUCTOR__12(std::string ** err_msg)"
// call: "casadi::GenericType()"
// params: []
extern "C"
    casadi::GenericType* casadi__GenericType__CONSTRUCTOR__12(std::string ** err_msg);
casadi::GenericType* casadi__GenericType__CONSTRUCTOR__12(std::string ** err_msg){
    try {

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


// ================== Normal method: "can_cast_to" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::can_cast_to"
// cWrapperName: "casadi__GenericType__can_cast_to__0"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__can_cast_to__0(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0)"
// call: "obj->can_cast_to(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType")))]
extern "C"
    int casadi__GenericType__can_cast_to__0(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0);
int casadi__GenericType__can_cast_to__0(std::string ** err_msg, casadi::GenericType* obj, casadi::GenericType* x0){
    try {
        casadi::GenericType x0_ = Marshaling<casadi::GenericType,casadi::GenericType*>::marshal(x0);

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


// ================== Normal method: "can_cast_to" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::can_cast_to"
// cWrapperName: "casadi__GenericType__can_cast_to__1"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__can_cast_to__1(std::string ** err_msg, casadi::GenericType* obj, int x0)"
// call: "obj->can_cast_to(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "opt_type")]
extern "C"
    int casadi__GenericType__can_cast_to__1(std::string ** err_msg, casadi::GenericType* obj, int x0);
int casadi__GenericType__can_cast_to__1(std::string ** err_msg, casadi::GenericType* obj, int x0){
    try {
        casadi::opt_type x0_ = Marshaling<casadi::opt_type,int>::marshal(x0);

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


// ================== Static method: "from_type" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::from_type"
// cWrapperName: "casadi__GenericType__from_type"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__GenericType__from_type(std::string ** err_msg, int x0)"
// call: "casadi::GenericType::from_type(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "opt_type")]
extern "C"
    casadi::GenericType* casadi__GenericType__from_type(std::string ** err_msg, int x0);
casadi::GenericType* casadi__GenericType__from_type(std::string ** err_msg, int x0){
    try {
        casadi::opt_type x0_ = Marshaling<casadi::opt_type,int>::marshal(x0);

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


// ================== Normal method: "getType" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::getType"
// cWrapperName: "casadi__GenericType__getType"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CEnum (Namespace ["casadi"]) (Name "opt_type")
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->getType()"
// params: []
extern "C"
    int casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__getType(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "get_description" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::get_description"
// cWrapperName: "casadi__GenericType__get_description"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->get_description()"
// params: []
extern "C"
    std::string* casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj);
std::string* casadi__GenericType__get_description(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Static method: "get_type_description" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::get_type_description"
// cWrapperName: "casadi__GenericType__get_type_description"
// protoArgs: "(std::string ** err_msg, int* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__GenericType__get_type_description(std::string ** err_msg, int* x0)"
// call: "casadi::GenericType::get_type_description(x0_)"
// params: [Ref (Const (CEnum (Namespace ["casadi"]) (Name "opt_type")))]
extern "C"
    std::string* casadi__GenericType__get_type_description(std::string ** err_msg, int* x0);
std::string* casadi__GenericType__get_type_description(std::string ** err_msg, int* x0){
    try {
        casadi::opt_type x0_ = Marshaling<casadi::opt_type,int*>::marshal(x0);

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


// ================== Normal method: "isBool" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isBool"
// cWrapperName: "casadi__GenericType__isBool"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isBool(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isBool()"
// params: []
extern "C"
    int casadi__GenericType__isBool(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isBool(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isDictionary" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isDictionary"
// cWrapperName: "casadi__GenericType__isDictionary"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isDictionary(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isDictionary()"
// params: []
extern "C"
    int casadi__GenericType__isDictionary(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isDictionary(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isDouble" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isDouble"
// cWrapperName: "casadi__GenericType__isDouble"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isDouble(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isDouble()"
// params: []
extern "C"
    int casadi__GenericType__isDouble(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isDouble(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isDoubleVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isDoubleVector"
// cWrapperName: "casadi__GenericType__isDoubleVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isDoubleVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isDoubleVector()"
// params: []
extern "C"
    int casadi__GenericType__isDoubleVector(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isDoubleVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isEmptyVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isEmptyVector"
// cWrapperName: "casadi__GenericType__isEmptyVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isEmptyVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isEmptyVector()"
// params: []
extern "C"
    int casadi__GenericType__isEmptyVector(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isEmptyVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isFunction" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isFunction"
// cWrapperName: "casadi__GenericType__isFunction"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isFunction(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isFunction()"
// params: []
extern "C"
    int casadi__GenericType__isFunction(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isFunction(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isInt" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isInt"
// cWrapperName: "casadi__GenericType__isInt"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isInt(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isInt()"
// params: []
extern "C"
    int casadi__GenericType__isInt(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isInt(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isIntVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isIntVector"
// cWrapperName: "casadi__GenericType__isIntVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isIntVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isIntVector()"
// params: []
extern "C"
    int casadi__GenericType__isIntVector(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isIntVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isSharedObject" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isSharedObject"
// cWrapperName: "casadi__GenericType__isSharedObject"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isSharedObject(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isSharedObject()"
// params: []
extern "C"
    int casadi__GenericType__isSharedObject(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isSharedObject(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isString" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isString"
// cWrapperName: "casadi__GenericType__isString"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isString(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isString()"
// params: []
extern "C"
    int casadi__GenericType__isString(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isString(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "isStringVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::isStringVector"
// cWrapperName: "casadi__GenericType__isStringVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__isStringVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->isStringVector()"
// params: []
extern "C"
    int casadi__GenericType__isStringVector(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__isStringVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toBool" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toBool"
// cWrapperName: "casadi__GenericType__toBool"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__toBool(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toBool()"
// params: []
extern "C"
    int casadi__GenericType__toBool(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__toBool(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toDouble" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toDouble"
// cWrapperName: "casadi__GenericType__toDouble"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__GenericType__toDouble(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toDouble()"
// params: []
extern "C"
    double casadi__GenericType__toDouble(std::string ** err_msg, casadi::GenericType* obj);
double casadi__GenericType__toDouble(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toDoubleVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toDoubleVector"
// cWrapperName: "casadi__GenericType__toDoubleVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: Const (StdVec CDouble)
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* casadi__GenericType__toDoubleVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toDoubleVector()"
// params: []
extern "C"
    std::vector< double >* casadi__GenericType__toDoubleVector(std::string ** err_msg, casadi::GenericType* obj);
std::vector< double >* casadi__GenericType__toDoubleVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

        std::vector< double > ret = obj->toDoubleVector();
        return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "toFunction" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toFunction"
// cWrapperName: "casadi__GenericType__toFunction"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Function"))
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__GenericType__toFunction(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toFunction()"
// params: []
extern "C"
    casadi::Function* casadi__GenericType__toFunction(std::string ** err_msg, casadi::GenericType* obj);
casadi::Function* casadi__GenericType__toFunction(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toInt" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toInt"
// cWrapperName: "casadi__GenericType__toInt"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__GenericType__toInt(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toInt()"
// params: []
extern "C"
    int casadi__GenericType__toInt(std::string ** err_msg, casadi::GenericType* obj);
int casadi__GenericType__toInt(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toIntVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toIntVector"
// cWrapperName: "casadi__GenericType__toIntVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__GenericType__toIntVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toIntVector()"
// params: []
extern "C"
    std::vector< int >* casadi__GenericType__toIntVector(std::string ** err_msg, casadi::GenericType* obj);
std::vector< int >* casadi__GenericType__toIntVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toSharedObject" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toSharedObject"
// cWrapperName: "casadi__GenericType__toSharedObject"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SharedObject"))
// cWrapperRetType: "casadi::SharedObject*"
// proto: "casadi::SharedObject* casadi__GenericType__toSharedObject(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toSharedObject()"
// params: []
extern "C"
    casadi::SharedObject* casadi__GenericType__toSharedObject(std::string ** err_msg, casadi::GenericType* obj);
casadi::SharedObject* casadi__GenericType__toSharedObject(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toString" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toString"
// cWrapperName: "casadi__GenericType__toString"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: Const StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__GenericType__toString(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toString()"
// params: []
extern "C"
    std::string* casadi__GenericType__toString(std::string ** err_msg, casadi::GenericType* obj);
std::string* casadi__GenericType__toString(std::string ** err_msg, casadi::GenericType* obj){
    try {

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


// ================== Normal method: "toStringVector" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toStringVector"
// cWrapperName: "casadi__GenericType__toStringVector"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: Const (StdVec StdString)
// cWrapperRetType: "std::vector< std::string* >*"
// proto: "std::vector< std::string* >* casadi__GenericType__toStringVector(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toStringVector()"
// params: []
extern "C"
    std::vector< std::string* >* casadi__GenericType__toStringVector(std::string ** err_msg, casadi::GenericType* obj);
std::vector< std::string* >* casadi__GenericType__toStringVector(std::string ** err_msg, casadi::GenericType* obj){
    try {

        std::vector< std::string > ret = obj->toStringVector();
        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "toVoidPointer" ===============
// class: "casadi::GenericType"
// cppName: "casadi::GenericType::toVoidPointer"
// cWrapperName: "casadi__GenericType__toVoidPointer"
// protoArgs: "(std::string ** err_msg, casadi::GenericType* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__GenericType__toVoidPointer(std::string ** err_msg, casadi::GenericType* obj)"
// call: "obj->toVoidPointer()"
// params: []
extern "C"
    void casadi__GenericType__toVoidPointer(std::string ** err_msg, casadi::GenericType* obj);
void casadi__GenericType__toVoidPointer(std::string ** err_msg, casadi::GenericType* obj){
    try {

    obj->toVoidPointer();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "HomotopyNLPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "HomotopyNLPSolver")
extern "C"
    void delete_casadi__HomotopyNLPSolver(casadi::HomotopyNLPSolver* obj);
void delete_casadi__HomotopyNLPSolver(casadi::HomotopyNLPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::HomotopyNLPSolver"
// cppName: "casadi::HomotopyNLPSolver"
// cWrapperName: "casadi__HomotopyNLPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "HomotopyNLPSolver")
// cWrapperRetType: "casadi::HomotopyNLPSolver*"
// proto: "casadi::HomotopyNLPSolver* casadi__HomotopyNLPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::HomotopyNLPSolver()"
// params: []
extern "C"
    casadi::HomotopyNLPSolver* casadi__HomotopyNLPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::HomotopyNLPSolver* casadi__HomotopyNLPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "IMatrix")===============
// classType: UserType (Namespace ["casadi"]) (Name "IMatrix")
extern "C"
    void delete_casadi__IMatrix(casadi::IMatrix* obj);
void delete_casadi__IMatrix(casadi::IMatrix* obj){
    delete obj;
}

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

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::IMatrix(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__2(std::string ** err_msg, double x0)"
// call: "casadi::IMatrix(x0_)"
// params: [CDouble]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__2(std::string ** err_msg, double x0);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__2(std::string ** err_msg, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1)"
// call: "casadi::IMatrix(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__3(std::string ** err_msg, casadi::Sparsity* x0, std::vector< int >* x1);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::IMatrix(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0, int* x1)"
// call: "casadi::IMatrix(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const CInt)]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0, int* x1);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0, int* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__6"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< int >* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__6(std::string ** err_msg, std::vector< std::vector< int >* >* x0)"
// call: "casadi::IMatrix(x0_)"
// params: [Ref (Const (StdVec (StdVec CInt)))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__6(std::string ** err_msg, std::vector< std::vector< int >* >* x0);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__6(std::string ** err_msg, std::vector< std::vector< int >* >* x0){
    try {
        std::vector< std::vector< int > > x0_ = Marshaling<std::vector< std::vector< int > >,std::vector< std::vector< int >* >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__7"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::IMatrix(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__7(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix"
// cWrapperName: "casadi__IMatrix__CONSTRUCTOR__8"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__8(std::string ** err_msg)"
// call: "casadi::IMatrix()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__8(std::string ** err_msg);
casadi::IMatrix* casadi__IMatrix__CONSTRUCTOR__8(std::string ** err_msg){
    try {

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


// ================== Normal method: "__add__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__add__"
// cWrapperName: "casadi__IMatrix____add__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____add__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__add__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____add__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____add__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__constpow__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__constpow__"
// cWrapperName: "casadi__IMatrix____constpow__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____constpow__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__constpow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____constpow__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____constpow__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__copysign__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__copysign__"
// cWrapperName: "casadi__IMatrix____copysign__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____copysign__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__copysign__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____copysign__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____copysign__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__div__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__div__"
// cWrapperName: "casadi__IMatrix____div__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____div__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__div__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____div__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____div__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__eq__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__eq__"
// cWrapperName: "casadi__IMatrix____eq__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____eq__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__eq__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____eq__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____eq__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__ge__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__ge__"
// cWrapperName: "casadi__IMatrix____ge__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____ge__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__ge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____ge__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____ge__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__gt__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__gt__"
// cWrapperName: "casadi__IMatrix____gt__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____gt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__gt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____gt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____gt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__le__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__le__"
// cWrapperName: "casadi__IMatrix____le__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____le__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__le__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____le__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____le__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__lt__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__lt__"
// cWrapperName: "casadi__IMatrix____lt__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____lt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__lt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____lt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____lt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__mldivide__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__mldivide__"
// cWrapperName: "casadi__IMatrix____mldivide__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____mldivide__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__mldivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____mldivide__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____mldivide__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__mpower__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__mpower__"
// cWrapperName: "casadi__IMatrix____mpower__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____mpower__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__mpower__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____mpower__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____mpower__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__mrdivide__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__mrdivide__"
// cWrapperName: "casadi__IMatrix____mrdivide__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____mrdivide__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__mrdivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____mrdivide__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____mrdivide__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__mul__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__mul__"
// cWrapperName: "casadi__IMatrix____mul__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____mul__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__mul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____mul__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____mul__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__ne__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__ne__"
// cWrapperName: "casadi__IMatrix____ne__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____ne__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__ne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____ne__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____ne__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__nonzero__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__nonzero__"
// cWrapperName: "casadi__IMatrix____nonzero__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix____nonzero__(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->__nonzero__()"
// params: []
extern "C"
    int casadi__IMatrix____nonzero__(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix____nonzero__(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "__pow__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__pow__"
// cWrapperName: "casadi__IMatrix____pow__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____pow__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__pow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____pow__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____pow__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__radd__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__radd__"
// cWrapperName: "casadi__IMatrix____radd__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____radd__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__radd__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____radd__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____radd__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rdiv__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rdiv__"
// cWrapperName: "casadi__IMatrix____rdiv__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rdiv__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rdiv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rdiv__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rdiv__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__req__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__req__"
// cWrapperName: "casadi__IMatrix____req__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____req__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__req__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____req__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____req__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rge__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rge__"
// cWrapperName: "casadi__IMatrix____rge__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rge__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rge__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rge__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rgt__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rgt__"
// cWrapperName: "casadi__IMatrix____rgt__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rgt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rgt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rgt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rgt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rle__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rle__"
// cWrapperName: "casadi__IMatrix____rle__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rle__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rle__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rle__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rle__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rlt__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rlt__"
// cWrapperName: "casadi__IMatrix____rlt__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rlt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rlt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rlt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rlt__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rmul__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rmul__"
// cWrapperName: "casadi__IMatrix____rmul__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rmul__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rmul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rmul__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rmul__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rne__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rne__"
// cWrapperName: "casadi__IMatrix____rne__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rne__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rne__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rne__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rsub__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rsub__"
// cWrapperName: "casadi__IMatrix____rsub__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rsub__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rsub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rsub__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rsub__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__rtruediv__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__rtruediv__"
// cWrapperName: "casadi__IMatrix____rtruediv__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____rtruediv__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__rtruediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____rtruediv__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____rtruediv__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__sub__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__sub__"
// cWrapperName: "casadi__IMatrix____sub__"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____sub__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__sub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____sub__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____sub__(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__truediv__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__truediv__"
// cWrapperName: "casadi__IMatrix____truediv____0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____truediv____0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____truediv____0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____truediv____0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "__truediv__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__truediv__"
// cWrapperName: "casadi__IMatrix____truediv____1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix____truediv____1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix____truediv____1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____truediv____1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "append" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::append"
// cWrapperName: "casadi__IMatrix__append"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__append(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->append(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__append(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
void casadi__IMatrix__append(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

    obj->append(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "appendColumns" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::appendColumns"
// cWrapperName: "casadi__IMatrix__appendColumns"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__appendColumns(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->appendColumns(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__appendColumns(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
void casadi__IMatrix__appendColumns(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

    obj->appendColumns(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "arccos" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arccos"
// cWrapperName: "casadi__IMatrix__arccos"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arccos(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->arccos()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__arccos(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__arccos(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "arccosh" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arccosh"
// cWrapperName: "casadi__IMatrix__arccosh"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arccosh(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->arccosh()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__arccosh(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__arccosh(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "arcsin" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arcsin"
// cWrapperName: "casadi__IMatrix__arcsin"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arcsin(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->arcsin()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__arcsin(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__arcsin(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "arcsinh" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arcsinh"
// cWrapperName: "casadi__IMatrix__arcsinh"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arcsinh(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->arcsinh()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__arcsinh(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__arcsinh(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "arctan" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arctan"
// cWrapperName: "casadi__IMatrix__arctan"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arctan(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->arctan()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__arctan(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__arctan(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "arctan2" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arctan2"
// cWrapperName: "casadi__IMatrix__arctan2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arctan2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->arctan2(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__arctan2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__arctan2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "arctanh" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::arctanh"
// cWrapperName: "casadi__IMatrix__arctanh"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__arctanh(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->arctanh()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__arctanh(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__arctanh(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "at" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::at"
// cWrapperName: "casadi__IMatrix__at"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__at(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->at(x0_)"
// params: [CInt]
extern "C"
    int casadi__IMatrix__at(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__at(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


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

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


// ================== Normal method: "ceil" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::ceil"
// cWrapperName: "casadi__IMatrix__ceil"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__ceil(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->ceil()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__ceil(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__ceil(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Static method: "className" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::className"
// cWrapperName: "casadi__IMatrix__className"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IMatrix__className(std::string ** err_msg)"
// call: "casadi::IMatrix::className()"
// params: []
extern "C"
    std::string* casadi__IMatrix__className(std::string ** err_msg);
std::string* casadi__IMatrix__className(std::string ** err_msg){
    try {

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


// ================== Normal method: "clear" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::clear"
// cWrapperName: "casadi__IMatrix__clear"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__clear(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->clear()"
// params: []
extern "C"
    void casadi__IMatrix__clear(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__clear(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->clear();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "colind" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::colind"
// cWrapperName: "casadi__IMatrix__colind__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__colind__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->colind(x0_)"
// params: [CInt]
extern "C"
    int casadi__IMatrix__colind__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__colind__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "colind" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::colind"
// cWrapperName: "casadi__IMatrix__colind__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__IMatrix__colind__1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->colind()"
// params: []
extern "C"
    std::vector< int >* casadi__IMatrix__colind__1(std::string ** err_msg, casadi::IMatrix* obj);
std::vector< int >* casadi__IMatrix__colind__1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "cos" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::cos"
// cWrapperName: "casadi__IMatrix__cos"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__cos(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->cos()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__cos(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__cos(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "cosh" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::cosh"
// cWrapperName: "casadi__IMatrix__cosh"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__cosh(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->cosh()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__cosh(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__cosh(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "data" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::data"
// cWrapperName: "casadi__IMatrix__data__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__IMatrix__data__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->data()"
// params: []
extern "C"
    std::vector< int >* casadi__IMatrix__data__0(std::string ** err_msg, casadi::IMatrix* obj);
std::vector< int >* casadi__IMatrix__data__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "data" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::data"
// cWrapperName: "casadi__IMatrix__data__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__IMatrix__data__1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->data()"
// params: []
extern "C"
    std::vector< int >* casadi__IMatrix__data__1(std::string ** err_msg, casadi::IMatrix* obj);
std::vector< int >* casadi__IMatrix__data__1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "densify" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::densify"
// cWrapperName: "casadi__IMatrix__densify__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__densify__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->densify()"
// params: []
extern "C"
    void casadi__IMatrix__densify__0(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__densify__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->densify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "densify" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::densify"
// cWrapperName: "casadi__IMatrix__densify__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__densify__1(std::string ** err_msg, casadi::IMatrix* obj, int* x0)"
// call: "obj->densify(x0_)"
// params: [Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__densify__1(std::string ** err_msg, casadi::IMatrix* obj, int* x0);
void casadi__IMatrix__densify__1(std::string ** err_msg, casadi::IMatrix* obj, int* x0){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);

    obj->densify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "dimString" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::dimString"
// cWrapperName: "casadi__IMatrix__dimString"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IMatrix__dimString(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->dimString()"
// params: []
extern "C"
    std::string* casadi__IMatrix__dimString(std::string ** err_msg, casadi::IMatrix* obj);
std::string* casadi__IMatrix__dimString(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "elem" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::elem"
// cWrapperName: "casadi__IMatrix__elem__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__elem__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->elem(x0_)"
// params: [CInt]
extern "C"
    int casadi__IMatrix__elem__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__elem__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "elem" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::elem"
// cWrapperName: "casadi__IMatrix__elem__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__elem__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->elem(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__IMatrix__elem__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
int casadi__IMatrix__elem__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "enlarge" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::enlarge"
// cWrapperName: "casadi__IMatrix__enlarge"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__enlarge(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__IMatrix__enlarge(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void casadi__IMatrix__enlarge(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

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


// ================== Normal method: "erase" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::erase"
// cWrapperName: "casadi__IMatrix__erase"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__erase(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__IMatrix__erase(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__IMatrix__erase(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->erase(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "erf" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::erf"
// cWrapperName: "casadi__IMatrix__erf"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__erf(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->erf()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__erf(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__erf(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "erfinv" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::erfinv"
// cWrapperName: "casadi__IMatrix__erfinv"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__erfinv(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->erfinv()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__erfinv(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__erfinv(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "exp" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::exp"
// cWrapperName: "casadi__IMatrix__exp"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__exp(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->exp()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__exp(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__exp(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Static method: "eye" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::eye"
// cWrapperName: "casadi__IMatrix__eye"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__eye(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::eye(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__eye(std::string ** err_msg, int x0);
casadi::IMatrix* casadi__IMatrix__eye(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "fabs" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::fabs"
// cWrapperName: "casadi__IMatrix__fabs"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__fabs(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->fabs()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__fabs(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__fabs(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "floor" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::floor"
// cWrapperName: "casadi__IMatrix__floor"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__floor(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->floor()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__floor(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__floor(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "fmax" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::fmax"
// cWrapperName: "casadi__IMatrix__fmax"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__fmax(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->fmax(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__fmax(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__fmax(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "fmin" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::fmin"
// cWrapperName: "casadi__IMatrix__fmin"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__fmin(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->fmin(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__fmin(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__fmin(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "fmod" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::fmod"
// cWrapperName: "casadi__IMatrix__fmod"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__fmod(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->fmod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__fmod(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__fmod(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "get" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::get"
// cWrapperName: "casadi__IMatrix__get__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__get__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->get(x0_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix"))]
extern "C"
    void casadi__IMatrix__get__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
void casadi__IMatrix__get__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::get"
// cWrapperName: "casadi__IMatrix__get__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__get__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__IMatrix__get__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1);
void casadi__IMatrix__get__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::get"
// cWrapperName: "casadi__IMatrix__get__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__get__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
// call: "obj->get(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    void casadi__IMatrix__get__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0);
void casadi__IMatrix__get__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::get"
// cWrapperName: "casadi__IMatrix__get__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__get__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (StdVec CInt),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__IMatrix__get__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1);
void casadi__IMatrix__get__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::get"
// cWrapperName: "casadi__IMatrix__get__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__get__4(std::string ** err_msg, casadi::IMatrix* obj, int* x0)"
// call: "obj->get(x0_)"
// params: [Ref CInt]
extern "C"
    void casadi__IMatrix__get__4(std::string ** err_msg, casadi::IMatrix* obj, int* x0);
void casadi__IMatrix__get__4(std::string ** err_msg, casadi::IMatrix* obj, int* x0){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::get"
// cWrapperName: "casadi__IMatrix__get__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__get__5(std::string ** err_msg, casadi::IMatrix* obj, int* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref CInt,CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__IMatrix__get__5(std::string ** err_msg, casadi::IMatrix* obj, int* x0, int x1);
void casadi__IMatrix__get__5(std::string ** err_msg, casadi::IMatrix* obj, int* x0, int x1){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getElement" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getElement"
// cWrapperName: "casadi__IMatrix__getElement__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__getElement__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->getElement(x0_)"
// params: [CInt]
extern "C"
    int casadi__IMatrix__getElement__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__getElement__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "getElement" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getElement"
// cWrapperName: "casadi__IMatrix__getElement__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__getElement__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->getElement(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__IMatrix__getElement__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
int casadi__IMatrix__getElement__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getEqualityCheckingDepth"
// cWrapperName: "casadi__IMatrix__getEqualityCheckingDepth"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__getEqualityCheckingDepth(std::string ** err_msg)"
// call: "casadi::IMatrix::getEqualityCheckingDepth()"
// params: []
extern "C"
    int casadi__IMatrix__getEqualityCheckingDepth(std::string ** err_msg);
int casadi__IMatrix__getEqualityCheckingDepth(std::string ** err_msg){
    try {

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


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getMaxNumCallsInPrint"
// cWrapperName: "casadi__IMatrix__getMaxNumCallsInPrint"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long casadi__IMatrix__getMaxNumCallsInPrint(std::string ** err_msg)"
// call: "casadi::IMatrix::getMaxNumCallsInPrint()"
// params: []
extern "C"
    long casadi__IMatrix__getMaxNumCallsInPrint(std::string ** err_msg);
long casadi__IMatrix__getMaxNumCallsInPrint(std::string ** err_msg){
    try {

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getNZ"
// cWrapperName: "casadi__IMatrix__getNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__getNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__getNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__getNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getNZ"
// cWrapperName: "casadi__IMatrix__getNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__getNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__getNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0);
casadi::IMatrix* casadi__IMatrix__getNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getNZ"
// cWrapperName: "casadi__IMatrix__getNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__getNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__getNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0);
casadi::IMatrix* casadi__IMatrix__getNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getNZ"
// cWrapperName: "casadi__IMatrix__getNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__getNZ__3(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->getNZ(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__getNZ__3(std::string ** err_msg, casadi::IMatrix* obj, int x0);
casadi::IMatrix* casadi__IMatrix__getNZ__3(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "getName" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getName"
// cWrapperName: "casadi__IMatrix__getName"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IMatrix__getName(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->getName()"
// params: []
extern "C"
    std::string* casadi__IMatrix__getName(std::string ** err_msg, casadi::IMatrix* obj);
std::string* casadi__IMatrix__getName(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "getValue" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getValue"
// cWrapperName: "casadi__IMatrix__getValue"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__IMatrix__getValue(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->getValue()"
// params: []
extern "C"
    double casadi__IMatrix__getValue(std::string ** err_msg, casadi::IMatrix* obj);
double casadi__IMatrix__getValue(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "hasNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::hasNZ"
// cWrapperName: "casadi__IMatrix__hasNZ"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__hasNZ(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__IMatrix__hasNZ(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
int casadi__IMatrix__hasNZ(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "hasNonStructuralZeros" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::hasNonStructuralZeros"
// cWrapperName: "casadi__IMatrix__hasNonStructuralZeros"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->hasNonStructuralZeros()"
// params: []
extern "C"
    int casadi__IMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__hasNonStructuralZeros(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "if_else_zero" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::if_else_zero"
// cWrapperName: "casadi__IMatrix__if_else_zero"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__if_else_zero(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->if_else_zero(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__if_else_zero(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__if_else_zero(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed"
// cWrapperName: "casadi__IMatrix__indexed__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0);
casadi::IMatrix* casadi__IMatrix__indexed__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed"
// cWrapperName: "casadi__IMatrix__indexed__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__indexed__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed"
// cWrapperName: "casadi__IMatrix__indexed__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__indexed__2(std::string ** err_msg, casadi::IMatrix* obj, 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 = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed"
// cWrapperName: "casadi__IMatrix__indexed__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::IMatrix* casadi__IMatrix__indexed__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed"
// cWrapperName: "casadi__IMatrix__indexed__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__indexed__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed"
// cWrapperName: "casadi__IMatrix__indexed__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::IMatrix* casadi__IMatrix__indexed__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_assignment"
// cWrapperName: "casadi__IMatrix__indexed_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
void casadi__IMatrix__indexed_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_assignment"
// cWrapperName: "casadi__IMatrix__indexed_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, casadi::IMatrix* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, casadi::IMatrix* x1);
void casadi__IMatrix__indexed_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, casadi::IMatrix* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_assignment"
// cWrapperName: "casadi__IMatrix__indexed_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__IMatrix__indexed_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_assignment"
// cWrapperName: "casadi__IMatrix__indexed_assignment__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_assignment__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_assignment__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2);
void casadi__IMatrix__indexed_assignment__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_assignment"
// cWrapperName: "casadi__IMatrix__indexed_assignment__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_assignment__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_assignment__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__IMatrix__indexed_assignment__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_assignment"
// cWrapperName: "casadi__IMatrix__indexed_assignment__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_assignment__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_assignment__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::IMatrix* x2);
void casadi__IMatrix__indexed_assignment__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::IMatrix* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_one_based"
// cWrapperName: "casadi__IMatrix__indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed_one_based__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed_one_based__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
casadi::IMatrix* casadi__IMatrix__indexed_one_based__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_one_based"
// cWrapperName: "casadi__IMatrix__indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed_one_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->indexed_one_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed_one_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__indexed_one_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_one_based"
// cWrapperName: "casadi__IMatrix__indexed_one_based__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed_one_based__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed_one_based__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__indexed_one_based__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_one_based_assignment"
// cWrapperName: "casadi__IMatrix__indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_one_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__indexed_one_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1);
void casadi__IMatrix__indexed_one_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_one_based_assignment"
// cWrapperName: "casadi__IMatrix__indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_one_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__indexed_one_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2);
void casadi__IMatrix__indexed_one_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int*>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_one_based_assignment"
// cWrapperName: "casadi__IMatrix__indexed_one_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_one_based_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_one_based_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
void casadi__IMatrix__indexed_one_based_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_zero_based"
// cWrapperName: "casadi__IMatrix__indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed_zero_based__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed_zero_based__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
casadi::IMatrix* casadi__IMatrix__indexed_zero_based__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_zero_based"
// cWrapperName: "casadi__IMatrix__indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed_zero_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->indexed_zero_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed_zero_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__indexed_zero_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_zero_based"
// cWrapperName: "casadi__IMatrix__indexed_zero_based__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__indexed_zero_based__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__indexed_zero_based__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__indexed_zero_based__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_zero_based_assignment"
// cWrapperName: "casadi__IMatrix__indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1);
void casadi__IMatrix__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_zero_based_assignment"
// cWrapperName: "casadi__IMatrix__indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2);
void casadi__IMatrix__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1, int* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int*>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::indexed_zero_based_assignment"
// cWrapperName: "casadi__IMatrix__indexed_zero_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
void casadi__IMatrix__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::inf"
// cWrapperName: "casadi__IMatrix__inf__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__inf__0(std::string ** err_msg)"
// call: "casadi::IMatrix::inf()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__inf__0(std::string ** err_msg);
casadi::IMatrix* casadi__IMatrix__inf__0(std::string ** err_msg){
    try {

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


// ================== Static method: "inf" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::inf"
// cWrapperName: "casadi__IMatrix__inf__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__inf__1(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::inf(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__inf__1(std::string ** err_msg, int x0);
casadi::IMatrix* casadi__IMatrix__inf__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "inf" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::inf"
// cWrapperName: "casadi__IMatrix__inf__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__inf__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::IMatrix::inf(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__inf__2(std::string ** err_msg, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__inf__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "inf" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::inf"
// cWrapperName: "casadi__IMatrix__inf__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__inf__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::IMatrix::inf(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__inf__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__inf__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "isConstant" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isConstant"
// cWrapperName: "casadi__IMatrix__isConstant"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isConstant(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isConstant()"
// params: []
extern "C"
    int casadi__IMatrix__isConstant(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isConstant(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isDense" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isDense"
// cWrapperName: "casadi__IMatrix__isDense"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isDense(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isDense()"
// params: []
extern "C"
    int casadi__IMatrix__isDense(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isDense(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isEmpty" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isEmpty"
// cWrapperName: "casadi__IMatrix__isEmpty__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isEmpty__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isEmpty()"
// params: []
extern "C"
    int casadi__IMatrix__isEmpty__0(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isEmpty__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isEmpty" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isEmpty"
// cWrapperName: "casadi__IMatrix__isEmpty__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isEmpty__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->isEmpty(x0_)"
// params: [CBool]
extern "C"
    int casadi__IMatrix__isEmpty__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__isEmpty__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "isEqual" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isEqual"
// cWrapperName: "casadi__IMatrix__isEqual"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isEqual(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->isEqual(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    int casadi__IMatrix__isEqual(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
int casadi__IMatrix__isEqual(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "isIdentity" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isIdentity"
// cWrapperName: "casadi__IMatrix__isIdentity"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isIdentity(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isIdentity()"
// params: []
extern "C"
    int casadi__IMatrix__isIdentity(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isIdentity(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isInteger" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isInteger"
// cWrapperName: "casadi__IMatrix__isInteger"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isInteger(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isInteger()"
// params: []
extern "C"
    int casadi__IMatrix__isInteger(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isInteger(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isMinusOne" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isMinusOne"
// cWrapperName: "casadi__IMatrix__isMinusOne"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isMinusOne(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isMinusOne()"
// params: []
extern "C"
    int casadi__IMatrix__isMinusOne(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isMinusOne(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isOne" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isOne"
// cWrapperName: "casadi__IMatrix__isOne"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isOne(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isOne()"
// params: []
extern "C"
    int casadi__IMatrix__isOne(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isOne(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isRegular" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isRegular"
// cWrapperName: "casadi__IMatrix__isRegular"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isRegular(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isRegular()"
// params: []
extern "C"
    int casadi__IMatrix__isRegular(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isRegular(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isScalar" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isScalar"
// cWrapperName: "casadi__IMatrix__isScalar__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isScalar__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isScalar()"
// params: []
extern "C"
    int casadi__IMatrix__isScalar__0(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isScalar__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isScalar" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isScalar"
// cWrapperName: "casadi__IMatrix__isScalar__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isScalar__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->isScalar(x0_)"
// params: [CBool]
extern "C"
    int casadi__IMatrix__isScalar__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__isScalar__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "isSmooth" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isSmooth"
// cWrapperName: "casadi__IMatrix__isSmooth"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isSmooth(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isSmooth()"
// params: []
extern "C"
    int casadi__IMatrix__isSmooth(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isSmooth(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isSquare" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isSquare"
// cWrapperName: "casadi__IMatrix__isSquare"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isSquare(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isSquare()"
// params: []
extern "C"
    int casadi__IMatrix__isSquare(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isSquare(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isSymbolic" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isSymbolic"
// cWrapperName: "casadi__IMatrix__isSymbolic"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isSymbolic(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isSymbolic()"
// params: []
extern "C"
    int casadi__IMatrix__isSymbolic(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isSymbolic(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isSymbolicSparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isSymbolicSparse"
// cWrapperName: "casadi__IMatrix__isSymbolicSparse"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isSymbolicSparse(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isSymbolicSparse()"
// params: []
extern "C"
    int casadi__IMatrix__isSymbolicSparse(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isSymbolicSparse(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isTril" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isTril"
// cWrapperName: "casadi__IMatrix__isTril"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isTril(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isTril()"
// params: []
extern "C"
    int casadi__IMatrix__isTril(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isTril(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isTriu" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isTriu"
// cWrapperName: "casadi__IMatrix__isTriu"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isTriu(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isTriu()"
// params: []
extern "C"
    int casadi__IMatrix__isTriu(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isTriu(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isVector" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isVector"
// cWrapperName: "casadi__IMatrix__isVector"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isVector(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isVector()"
// params: []
extern "C"
    int casadi__IMatrix__isVector(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isVector(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "isZero" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::isZero"
// cWrapperName: "casadi__IMatrix__isZero"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__isZero(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->isZero()"
// params: []
extern "C"
    int casadi__IMatrix__isZero(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__isZero(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "log" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::log"
// cWrapperName: "casadi__IMatrix__log"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__log(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->log()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__log(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__log(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "log10" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::log10"
// cWrapperName: "casadi__IMatrix__log10"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__log10(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->log10()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__log10(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__log10(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "logic_and" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::logic_and"
// cWrapperName: "casadi__IMatrix__logic_and"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__logic_and(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->logic_and(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__logic_and(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__logic_and(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "logic_not" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::logic_not"
// cWrapperName: "casadi__IMatrix__logic_not"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__logic_not(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->logic_not()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__logic_not(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__logic_not(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "logic_or" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::logic_or"
// cWrapperName: "casadi__IMatrix__logic_or"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__logic_or(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->logic_or(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__logic_or(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__logic_or(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


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

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


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

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


// ================== Normal method: "mul" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul"
// cWrapperName: "casadi__IMatrix__mul__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__mul__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->mul(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__mul__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__mul__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "mul" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul"
// cWrapperName: "casadi__IMatrix__mul__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__mul__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__mul__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1);
casadi::IMatrix* casadi__IMatrix__mul__1(std::string ** err_msg, casadi::IMatrix* obj, 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 = obj->mul(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul_full" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul_full"
// cWrapperName: "casadi__IMatrix__mul_full__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__mul_full__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->mul_full(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__mul_full__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__mul_full__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "mul_full" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul_full"
// cWrapperName: "casadi__IMatrix__mul_full__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__mul_full__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__mul_full__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1);
casadi::IMatrix* casadi__IMatrix__mul_full__1(std::string ** err_msg, casadi::IMatrix* obj, 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 = obj->mul_full(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul_no_alloc_nn"
// cWrapperName: "casadi__IMatrix__mul_no_alloc_nn__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__mul_no_alloc_nn__0(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::IMatrix::mul_no_alloc_nn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
extern "C"
    void casadi__IMatrix__mul_no_alloc_nn__0(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
void casadi__IMatrix__mul_no_alloc_nn__0(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::IMatrix::mul_no_alloc_nn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

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


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

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


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul_no_alloc_tn"
// cWrapperName: "casadi__IMatrix__mul_no_alloc_tn__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__mul_no_alloc_tn__0(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::IMatrix::mul_no_alloc_tn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
extern "C"
    void casadi__IMatrix__mul_no_alloc_tn__0(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
void casadi__IMatrix__mul_no_alloc_tn__0(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::IMatrix::mul_no_alloc_tn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

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


// ================== Normal method: "mul_smart" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::mul_smart"
// cWrapperName: "casadi__IMatrix__mul_smart"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__mul_smart(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__mul_smart(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1);
casadi::IMatrix* casadi__IMatrix__mul_smart(std::string ** err_msg, casadi::IMatrix* obj, 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 = obj->mul_smart(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nan"
// cWrapperName: "casadi__IMatrix__nan__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nan__0(std::string ** err_msg)"
// call: "casadi::IMatrix::nan()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__nan__0(std::string ** err_msg);
casadi::IMatrix* casadi__IMatrix__nan__0(std::string ** err_msg){
    try {

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


// ================== Static method: "nan" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nan"
// cWrapperName: "casadi__IMatrix__nan__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nan__1(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::nan(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nan__1(std::string ** err_msg, int x0);
casadi::IMatrix* casadi__IMatrix__nan__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "nan" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nan"
// cWrapperName: "casadi__IMatrix__nan__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nan__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::IMatrix::nan(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nan__2(std::string ** err_msg, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__nan__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "nan" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nan"
// cWrapperName: "casadi__IMatrix__nan__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nan__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::IMatrix::nan(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nan__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__nan__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "numel" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::numel"
// cWrapperName: "casadi__IMatrix__numel"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__numel(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->numel()"
// params: []
extern "C"
    int casadi__IMatrix__numel(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__numel(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "nz_indexed" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed"
// cWrapperName: "casadi__IMatrix__nz_indexed"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nz_indexed(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0)"
// call: "obj->nz_indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nz_indexed(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0);
casadi::IMatrix* casadi__IMatrix__nz_indexed(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_assignment"
// cWrapperName: "casadi__IMatrix__nz_indexed_assignment"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__nz_indexed_assignment(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__nz_indexed_assignment(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
void casadi__IMatrix__nz_indexed_assignment(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_one_based"
// cWrapperName: "casadi__IMatrix__nz_indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nz_indexed_one_based__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nz_indexed_one_based__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__nz_indexed_one_based__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_one_based"
// cWrapperName: "casadi__IMatrix__nz_indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nz_indexed_one_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nz_indexed_one_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
casadi::IMatrix* casadi__IMatrix__nz_indexed_one_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__IMatrix__nz_indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
void casadi__IMatrix__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__IMatrix__nz_indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1);
void casadi__IMatrix__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_zero_based"
// cWrapperName: "casadi__IMatrix__nz_indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nz_indexed_zero_based__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nz_indexed_zero_based__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__nz_indexed_zero_based__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_zero_based"
// cWrapperName: "casadi__IMatrix__nz_indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__nz_indexed_zero_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__nz_indexed_zero_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
casadi::IMatrix* casadi__IMatrix__nz_indexed_zero_based__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__IMatrix__nz_indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
void casadi__IMatrix__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__IMatrix__nz_indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1);
void casadi__IMatrix__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::IMatrix* obj, int x0, int* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::ones"
// cWrapperName: "casadi__IMatrix__ones__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__ones__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::IMatrix::ones(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__ones__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__ones__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Static method: "ones" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::ones"
// cWrapperName: "casadi__IMatrix__ones__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__ones__1(std::string ** err_msg)"
// call: "casadi::IMatrix::ones()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__ones__1(std::string ** err_msg);
casadi::IMatrix* casadi__IMatrix__ones__1(std::string ** err_msg){
    try {

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


// ================== Static method: "ones" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::ones"
// cWrapperName: "casadi__IMatrix__ones__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__ones__2(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::ones(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__ones__2(std::string ** err_msg, int x0);
casadi::IMatrix* casadi__IMatrix__ones__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "ones" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::ones"
// cWrapperName: "casadi__IMatrix__ones__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__ones__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::IMatrix::ones(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__ones__3(std::string ** err_msg, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__ones__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "printDense" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::printDense"
// cWrapperName: "casadi__IMatrix__printDense"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__printDense(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->printDense()"
// params: []
extern "C"
    void casadi__IMatrix__printDense(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__printDense(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->printDense();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printScalar" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::printScalar"
// cWrapperName: "casadi__IMatrix__printScalar"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__printScalar(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->printScalar()"
// params: []
extern "C"
    void casadi__IMatrix__printScalar(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__printScalar(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->printScalar();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printSparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::printSparse"
// cWrapperName: "casadi__IMatrix__printSparse"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__printSparse(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->printSparse()"
// params: []
extern "C"
    void casadi__IMatrix__printSparse(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__printSparse(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->printSparse();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printVector" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::printVector"
// cWrapperName: "casadi__IMatrix__printVector"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__printVector(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->printVector()"
// params: []
extern "C"
    void casadi__IMatrix__printVector(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__printVector(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->printVector();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printme" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::printme"
// cWrapperName: "casadi__IMatrix__printme"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__printme(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->printme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__printme(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix__printme(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Static method: "quad_form" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::quad_form"
// cWrapperName: "casadi__IMatrix__quad_form"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__quad_form(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "casadi::IMatrix::quad_form(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    int casadi__IMatrix__quad_form(std::string ** err_msg, casadi::IMatrix* x0, std::vector< int >* x1);
int casadi__IMatrix__quad_form(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);

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


// ================== Normal method: "remove" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::remove"
// cWrapperName: "casadi__IMatrix__remove"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__remove(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->remove(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__IMatrix__remove(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__IMatrix__remove(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->remove(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::repmat"
// cWrapperName: "casadi__IMatrix__repmat__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__repmat__0(std::string ** err_msg, casadi::IMatrix* x0, int x1)"
// call: "casadi::IMatrix::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__repmat__0(std::string ** err_msg, casadi::IMatrix* x0, int x1);
casadi::IMatrix* casadi__IMatrix__repmat__0(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);

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


// ================== Static method: "repmat" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::repmat"
// cWrapperName: "casadi__IMatrix__repmat__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__repmat__1(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2)"
// call: "casadi::IMatrix::repmat(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__repmat__1(std::string ** err_msg, casadi::IMatrix* x0, int x1, int x2);
casadi::IMatrix* casadi__IMatrix__repmat__1(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::IMatrix::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;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::repmat"
// cWrapperName: "casadi__IMatrix__repmat__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__repmat__2(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1)"
// call: "casadi::IMatrix::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__repmat__2(std::string ** err_msg, casadi::IMatrix* x0, casadi::Sparsity* x1);
casadi::IMatrix* casadi__IMatrix__repmat__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::IMatrix::repmat(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::repmat"
// cWrapperName: "casadi__IMatrix__repmat__3"
// protoArgs: "(std::string ** err_msg, int* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__repmat__3(std::string ** err_msg, int* x0, casadi::Sparsity* x1)"
// call: "casadi::IMatrix::repmat(x0_, x1_)"
// params: [Ref (Const CInt),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__repmat__3(std::string ** err_msg, int* x0, casadi::Sparsity* x1);
casadi::IMatrix* casadi__IMatrix__repmat__3(std::string ** err_msg, int* x0, casadi::Sparsity* x1){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

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


// ================== Normal method: "reserve" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::reserve"
// cWrapperName: "casadi__IMatrix__reserve__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__reserve__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__IMatrix__reserve__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
void casadi__IMatrix__reserve__0(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reserve" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::reserve"
// cWrapperName: "casadi__IMatrix__reserve__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__reserve__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->reserve(x0_)"
// params: [CInt]
extern "C"
    void casadi__IMatrix__reserve__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
void casadi__IMatrix__reserve__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->reserve(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "resize" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::resize"
// cWrapperName: "casadi__IMatrix__resize"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__resize(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__IMatrix__resize(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
void casadi__IMatrix__resize(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "row" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::row"
// cWrapperName: "casadi__IMatrix__row__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__row__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->row(x0_)"
// params: [CInt]
extern "C"
    int casadi__IMatrix__row__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__row__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "row" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::row"
// cWrapperName: "casadi__IMatrix__row__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__IMatrix__row__1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->row()"
// params: []
extern "C"
    std::vector< int >* casadi__IMatrix__row__1(std::string ** err_msg, casadi::IMatrix* obj);
std::vector< int >* casadi__IMatrix__row__1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sanityCheck"
// cWrapperName: "casadi__IMatrix__sanityCheck__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__sanityCheck__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sanityCheck()"
// params: []
extern "C"
    void casadi__IMatrix__sanityCheck__0(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__sanityCheck__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->sanityCheck();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sanityCheck"
// cWrapperName: "casadi__IMatrix__sanityCheck__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__sanityCheck__1(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
// params: [CBool]
extern "C"
    void casadi__IMatrix__sanityCheck__1(std::string ** err_msg, casadi::IMatrix* obj, int x0);
void casadi__IMatrix__sanityCheck__1(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

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


// ================== Normal method: "set" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::set"
// cWrapperName: "casadi__IMatrix__set__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__set__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)"
// call: "obj->set(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__set__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
void casadi__IMatrix__set__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::set"
// cWrapperName: "casadi__IMatrix__set__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__set__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__IMatrix__set__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1);
void casadi__IMatrix__set__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::set"
// cWrapperName: "casadi__IMatrix__set__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__set__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0)"
// call: "obj->set(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    void casadi__IMatrix__set__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0);
void casadi__IMatrix__set__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::set"
// cWrapperName: "casadi__IMatrix__set__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__set__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__IMatrix__set__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1);
void casadi__IMatrix__set__3(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::set"
// cWrapperName: "casadi__IMatrix__set__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__set__4(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->set(x0_)"
// params: [CInt]
extern "C"
    void casadi__IMatrix__set__4(std::string ** err_msg, casadi::IMatrix* obj, int x0);
void casadi__IMatrix__set__4(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::set"
// cWrapperName: "casadi__IMatrix__set__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__set__5(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [CInt,CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__IMatrix__set__5(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
void casadi__IMatrix__set__5(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setAll" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setAll"
// cWrapperName: "casadi__IMatrix__setAll"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setAll(std::string ** err_msg, casadi::IMatrix* obj, int* x0)"
// call: "obj->setAll(x0_)"
// params: [Ref (Const CInt)]
extern "C"
    void casadi__IMatrix__setAll(std::string ** err_msg, casadi::IMatrix* obj, int* x0);
void casadi__IMatrix__setAll(std::string ** err_msg, casadi::IMatrix* obj, int* x0){
    try {
        int x0_ = Marshaling<int,int*>::marshal(x0);

    obj->setAll(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setEqualityCheckingDepth"
// cWrapperName: "casadi__IMatrix__setEqualityCheckingDepth__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setEqualityCheckingDepth__0(std::string ** err_msg)"
// call: "casadi::IMatrix::setEqualityCheckingDepth()"
// params: []
extern "C"
    void casadi__IMatrix__setEqualityCheckingDepth__0(std::string ** err_msg);
void casadi__IMatrix__setEqualityCheckingDepth__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setEqualityCheckingDepth"
// cWrapperName: "casadi__IMatrix__setEqualityCheckingDepth__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::setEqualityCheckingDepth(x0_)"
// params: [CInt]
extern "C"
    void casadi__IMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
void casadi__IMatrix__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setMaxNumCallsInPrint"
// cWrapperName: "casadi__IMatrix__setMaxNumCallsInPrint__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setMaxNumCallsInPrint__0(std::string ** err_msg)"
// call: "casadi::IMatrix::setMaxNumCallsInPrint()"
// params: []
extern "C"
    void casadi__IMatrix__setMaxNumCallsInPrint__0(std::string ** err_msg);
void casadi__IMatrix__setMaxNumCallsInPrint__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setMaxNumCallsInPrint"
// cWrapperName: "casadi__IMatrix__setMaxNumCallsInPrint__1"
// protoArgs: "(std::string ** err_msg, long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0)"
// call: "casadi::IMatrix::setMaxNumCallsInPrint(x0_)"
// params: [CLong]
extern "C"
    void casadi__IMatrix__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0);
void casadi__IMatrix__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0){
    try {
        long x0_ = Marshaling<long,long>::marshal(x0);

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


// ================== Normal method: "setNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setNZ"
// cWrapperName: "casadi__IMatrix__setNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setNZ__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
void casadi__IMatrix__setNZ__0(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setNZ"
// cWrapperName: "casadi__IMatrix__setNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
void casadi__IMatrix__setNZ__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setNZ"
// cWrapperName: "casadi__IMatrix__setNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1);
void casadi__IMatrix__setNZ__2(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setNZ"
// cWrapperName: "casadi__IMatrix__setNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setNZ__3(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setNZ__3(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1);
void casadi__IMatrix__setNZ__3(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setPrecision" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setPrecision"
// cWrapperName: "casadi__IMatrix__setPrecision"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setPrecision(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::setPrecision(x0_)"
// params: [CInt]
extern "C"
    void casadi__IMatrix__setPrecision(std::string ** err_msg, int x0);
void casadi__IMatrix__setPrecision(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "setScientific" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setScientific"
// cWrapperName: "casadi__IMatrix__setScientific"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setScientific(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::setScientific(x0_)"
// params: [CBool]
extern "C"
    void casadi__IMatrix__setScientific(std::string ** err_msg, int x0);
void casadi__IMatrix__setScientific(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "setSparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSparse"
// cWrapperName: "casadi__IMatrix__setSparse__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__setSparse__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__setSparse__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__setSparse__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "setSparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSparse"
// cWrapperName: "casadi__IMatrix__setSparse__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__setSparse__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
extern "C"
    casadi::IMatrix* casadi__IMatrix__setSparse__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1);
casadi::IMatrix* casadi__IMatrix__setSparse__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

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


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    void casadi__IMatrix__setSub__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1, int x2);
void casadi__IMatrix__setSub__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Sparsity* x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Const CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__IMatrix__setSub__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2);
void casadi__IMatrix__setSub__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::Slice* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    void casadi__IMatrix__setSub__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, int x2);
void casadi__IMatrix__setSub__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, int x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setSub__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__IMatrix__setSub__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setSub__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2);
void casadi__IMatrix__setSub__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::IMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__IMatrix__setSub__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2);
void casadi__IMatrix__setSub__5(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::Slice* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__6"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setSub__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2);
void casadi__IMatrix__setSub__6(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, casadi::IMatrix* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__7"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__7(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__IMatrix__setSub__7(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::IMatrix* x2);
void casadi__IMatrix__setSub__7(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::IMatrix* 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);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__8"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__8(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    void casadi__IMatrix__setSub__8(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, int x2);
void casadi__IMatrix__setSub__8(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__10"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__IMatrix__setSub__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::Slice* x2);
void casadi__IMatrix__setSub__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::Slice* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__11"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__11(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__IMatrix__setSub__11(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::Slice* x2);
void casadi__IMatrix__setSub__11(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, casadi::Slice* 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);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__12"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__12(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__IMatrix__setSub__12(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, std::vector< int >* x2);
void casadi__IMatrix__setSub__12(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1, std::vector< int >* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__13"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__13(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__IMatrix__setSub__13(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, std::vector< int >* x2);
void casadi__IMatrix__setSub__13(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


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

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__15"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__15(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt)),CInt]
extern "C"
    void casadi__IMatrix__setSub__15(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, int x2);
void casadi__IMatrix__setSub__15(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1, 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);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setSub"
// cWrapperName: "casadi__IMatrix__setSub__16"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setSub__16(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt,CInt]
extern "C"
    void casadi__IMatrix__setSub__16(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1, int x2);
void casadi__IMatrix__setSub__16(std::string ** err_msg, casadi::IMatrix* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setWidth" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setWidth"
// cWrapperName: "casadi__IMatrix__setWidth"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setWidth(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::setWidth(x0_)"
// params: [CInt]
extern "C"
    void casadi__IMatrix__setWidth(std::string ** err_msg, int x0);
void casadi__IMatrix__setWidth(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "setZero" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::setZero"
// cWrapperName: "casadi__IMatrix__setZero"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__setZero(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->setZero()"
// params: []
extern "C"
    void casadi__IMatrix__setZero(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__setZero(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->setZero();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sign" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sign"
// cWrapperName: "casadi__IMatrix__sign"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sign(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sign()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__sign(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__sign(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sin" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sin"
// cWrapperName: "casadi__IMatrix__sin"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sin(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sin()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__sin(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__sin(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sinh" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sinh"
// cWrapperName: "casadi__IMatrix__sinh"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sinh(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sinh()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__sinh(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__sinh(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "size" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::size"
// cWrapperName: "casadi__IMatrix__size__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__size__0(std::string ** err_msg, casadi::IMatrix* obj, int x0)"
// call: "obj->size(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    int casadi__IMatrix__size__0(std::string ** err_msg, casadi::IMatrix* obj, int x0);
int casadi__IMatrix__size__0(std::string ** err_msg, casadi::IMatrix* obj, int x0){
    try {
        casadi::SparsityType x0_ = Marshaling<casadi::SparsityType,int>::marshal(x0);

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


// ================== Normal method: "size" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::size"
// cWrapperName: "casadi__IMatrix__size__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__size__1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->size()"
// params: []
extern "C"
    int casadi__IMatrix__size__1(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__size__1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "size1" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::size1"
// cWrapperName: "casadi__IMatrix__size1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__size1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->size1()"
// params: []
extern "C"
    int casadi__IMatrix__size1(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__size1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "size2" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::size2"
// cWrapperName: "casadi__IMatrix__size2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__size2(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->size2()"
// params: []
extern "C"
    int casadi__IMatrix__size2(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__size2(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sizeD" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sizeD"
// cWrapperName: "casadi__IMatrix__sizeD"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__sizeD(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sizeD()"
// params: []
extern "C"
    int casadi__IMatrix__sizeD(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__sizeD(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sizeL" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sizeL"
// cWrapperName: "casadi__IMatrix__sizeL"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__sizeL(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sizeL()"
// params: []
extern "C"
    int casadi__IMatrix__sizeL(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__sizeL(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sizeU" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sizeU"
// cWrapperName: "casadi__IMatrix__sizeU"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__sizeU(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sizeU()"
// params: []
extern "C"
    int casadi__IMatrix__sizeU(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__sizeU(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Static method: "sparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparse"
// cWrapperName: "casadi__IMatrix__sparse__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sparse__0(std::string ** err_msg)"
// call: "casadi::IMatrix::sparse()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__sparse__0(std::string ** err_msg);
casadi::IMatrix* casadi__IMatrix__sparse__0(std::string ** err_msg){
    try {

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


// ================== Static method: "sparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparse"
// cWrapperName: "casadi__IMatrix__sparse__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sparse__1(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::sparse(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sparse__1(std::string ** err_msg, int x0);
casadi::IMatrix* casadi__IMatrix__sparse__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "sparse" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparse"
// cWrapperName: "casadi__IMatrix__sparse__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sparse__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::IMatrix::sparse(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sparse__2(std::string ** err_msg, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__sparse__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sparsify" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparsify"
// cWrapperName: "casadi__IMatrix__sparsify__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__sparsify__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sparsify()"
// params: []
extern "C"
    void casadi__IMatrix__sparsify__0(std::string ** err_msg, casadi::IMatrix* obj);
void casadi__IMatrix__sparsify__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

    obj->sparsify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sparsify" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparsify"
// cWrapperName: "casadi__IMatrix__sparsify__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IMatrix__sparsify__1(std::string ** err_msg, casadi::IMatrix* obj, double x0)"
// call: "obj->sparsify(x0_)"
// params: [CDouble]
extern "C"
    void casadi__IMatrix__sparsify__1(std::string ** err_msg, casadi::IMatrix* obj, double x0);
void casadi__IMatrix__sparsify__1(std::string ** err_msg, casadi::IMatrix* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->sparsify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sparsity" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparsity"
// cWrapperName: "casadi__IMatrix__sparsity__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__IMatrix__sparsity__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__IMatrix__sparsity__0(std::string ** err_msg, casadi::IMatrix* obj);
casadi::Sparsity* casadi__IMatrix__sparsity__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sparsity" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparsity"
// cWrapperName: "casadi__IMatrix__sparsity__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__IMatrix__sparsity__1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__IMatrix__sparsity__1(std::string ** err_msg, casadi::IMatrix* obj);
casadi::Sparsity* casadi__IMatrix__sparsity__1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparsityRef"
// cWrapperName: "casadi__IMatrix__sparsityRef__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__IMatrix__sparsityRef__0(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__IMatrix__sparsityRef__0(std::string ** err_msg, casadi::IMatrix* obj);
casadi::Sparsity* casadi__IMatrix__sparsityRef__0(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sparsityRef"
// cWrapperName: "casadi__IMatrix__sparsityRef__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__IMatrix__sparsityRef__1(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__IMatrix__sparsityRef__1(std::string ** err_msg, casadi::IMatrix* obj);
casadi::Sparsity* casadi__IMatrix__sparsityRef__1(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sqrt" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sqrt"
// cWrapperName: "casadi__IMatrix__sqrt"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sqrt(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->sqrt()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__sqrt(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__sqrt(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__0"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0)"
// call: "obj->sub(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__sub__0(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__1"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1);
casadi::IMatrix* casadi__IMatrix__sub__1(std::string ** err_msg, casadi::IMatrix* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__2"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__2(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__sub__2(std::string ** err_msg, casadi::IMatrix* obj, 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 = obj->sub(x0_, x1_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__3"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__sub__3(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__4"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::IMatrix* casadi__IMatrix__sub__4(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__5(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__5(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__sub__5(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::IMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__6"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__6(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__6(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__sub__6(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::IMatrix* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__7"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__7(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__7(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1);
casadi::IMatrix* casadi__IMatrix__sub__7(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__8"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__8(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__8(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0, std::vector< int >* x1);
casadi::IMatrix* casadi__IMatrix__sub__8(std::string ** err_msg, casadi::IMatrix* obj, 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);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__9"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__9(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__9(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::Slice* x1);
casadi::IMatrix* casadi__IMatrix__sub__9(std::string ** err_msg, casadi::IMatrix* obj, int x0, casadi::Slice* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__10"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, int x1);
casadi::IMatrix* casadi__IMatrix__sub__10(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, int x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__11"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__11(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__11(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::IMatrix* casadi__IMatrix__sub__11(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__12"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__12(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__12(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::Slice* x1);
casadi::IMatrix* casadi__IMatrix__sub__12(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, casadi::Slice* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__13"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__13(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__13(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, std::vector< int >* x1);
casadi::IMatrix* casadi__IMatrix__sub__13(std::string ** err_msg, casadi::IMatrix* obj, casadi::Slice* x0, std::vector< int >* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__14"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__14(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__14(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1);
casadi::IMatrix* casadi__IMatrix__sub__14(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__15"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__15(std::string ** err_msg, casadi::IMatrix* obj, int x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__15(std::string ** err_msg, casadi::IMatrix* obj, int x0, std::vector< int >* x1);
casadi::IMatrix* casadi__IMatrix__sub__15(std::string ** err_msg, casadi::IMatrix* obj, int x0, std::vector< int >* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__16"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__16(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__16(std::string ** err_msg, casadi::IMatrix* obj, std::vector< int >* x0, int x1);
casadi::IMatrix* casadi__IMatrix__sub__16(std::string ** err_msg, casadi::IMatrix* obj, 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);

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


// ================== Normal method: "sub" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sub"
// cWrapperName: "casadi__IMatrix__sub__17"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sub__17(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sub__17(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__sub__17(std::string ** err_msg, casadi::IMatrix* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::IMatrix* >* >* casadi__IMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// call: "casadi::IMatrix::sym(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::IMatrix* >* >* casadi__IMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< casadi::IMatrix* >* >* casadi__IMatrix__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

        std::vector< std::vector< casadi::IMatrix > > ret = casadi::IMatrix::sym(x0_, x1_, x2_, x3_, x4_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__1"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix")))
// cWrapperRetType: "std::vector< std::vector< casadi::IMatrix* >* >*"
// proto: "std::vector< std::vector< casadi::IMatrix* >* >* casadi__IMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// call: "casadi::IMatrix::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::IMatrix* >* >* casadi__IMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< casadi::IMatrix* >* >* casadi__IMatrix__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< std::vector< casadi::IMatrix > > ret = casadi::IMatrix::sym(x0_, x1_, x2_, x3_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__2"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* casadi__IMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// call: "casadi::IMatrix::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CInt,CInt]
extern "C"
    std::vector< casadi::IMatrix* >* casadi__IMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
std::vector< casadi::IMatrix* >* casadi__IMatrix__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< casadi::IMatrix > ret = casadi::IMatrix::sym(x0_, x1_, x2_, x3_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__3"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "IMatrix"))
// cWrapperRetType: "std::vector< casadi::IMatrix* >*"
// proto: "std::vector< casadi::IMatrix* >* casadi__IMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// call: "casadi::IMatrix::sym(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    std::vector< casadi::IMatrix* >* casadi__IMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
std::vector< casadi::IMatrix* >* casadi__IMatrix__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< casadi::IMatrix > ret = casadi::IMatrix::sym(x0_, x1_, x2_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__4"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// call: "casadi::IMatrix::sym(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
casadi::IMatrix* casadi__IMatrix__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

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


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__5"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sym__5(std::string ** err_msg, std::string* x0)"
// call: "casadi::IMatrix::sym(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sym__5(std::string ** err_msg, std::string* x0);
casadi::IMatrix* casadi__IMatrix__sym__5(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Static method: "sym" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::sym"
// cWrapperName: "casadi__IMatrix__sym__6"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__sym__6(std::string ** err_msg, std::string* x0, int x1)"
// call: "casadi::IMatrix::sym(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__sym__6(std::string ** err_msg, std::string* x0, int x1);
casadi::IMatrix* casadi__IMatrix__sym__6(std::string ** err_msg, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


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

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


// ================== Normal method: "tan" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::tan"
// cWrapperName: "casadi__IMatrix__tan"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__tan(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->tan()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__tan(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__tan(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "tanh" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::tanh"
// cWrapperName: "casadi__IMatrix__tanh"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__tanh(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->tanh()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__tanh(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__tanh(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "toScalar" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::toScalar"
// cWrapperName: "casadi__IMatrix__toScalar"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: Const CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__toScalar(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->toScalar()"
// params: []
extern "C"
    int casadi__IMatrix__toScalar(std::string ** err_msg, casadi::IMatrix* obj);
int casadi__IMatrix__toScalar(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Normal method: "trans" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::trans"
// cWrapperName: "casadi__IMatrix__trans"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__trans(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->trans()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__trans(std::string ** err_msg, casadi::IMatrix* obj);
casadi::IMatrix* casadi__IMatrix__trans(std::string ** err_msg, casadi::IMatrix* obj){
    try {

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


// ================== Static method: "triplet" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::triplet"
// cWrapperName: "casadi__IMatrix__triplet__0"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4)"
// call: "casadi::IMatrix::triplet(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4);
casadi::IMatrix* casadi__IMatrix__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::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);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

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


// ================== Static method: "triplet" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::triplet"
// cWrapperName: "casadi__IMatrix__triplet__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "casadi::IMatrix::triplet(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
casadi::IMatrix* casadi__IMatrix__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::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::IMatrix ret = casadi::IMatrix::triplet(x0_, x1_, x2_);
        return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "unary" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::unary"
// cWrapperName: "casadi__IMatrix__unary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__unary(std::string ** err_msg, int x0, casadi::IMatrix* x1)"
// call: "casadi::IMatrix::unary(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__unary(std::string ** err_msg, int x0, casadi::IMatrix* x1);
casadi::IMatrix* casadi__IMatrix__unary(std::string ** err_msg, int x0, casadi::IMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Static method: "zeros" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::zeros"
// cWrapperName: "casadi__IMatrix__zeros__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__zeros__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::IMatrix::zeros(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::IMatrix* casadi__IMatrix__zeros__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::IMatrix* casadi__IMatrix__zeros__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Static method: "zeros" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::zeros"
// cWrapperName: "casadi__IMatrix__zeros__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__zeros__1(std::string ** err_msg)"
// call: "casadi::IMatrix::zeros()"
// params: []
extern "C"
    casadi::IMatrix* casadi__IMatrix__zeros__1(std::string ** err_msg);
casadi::IMatrix* casadi__IMatrix__zeros__1(std::string ** err_msg){
    try {

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


// ================== Static method: "zeros" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::zeros"
// cWrapperName: "casadi__IMatrix__zeros__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__zeros__2(std::string ** err_msg, int x0)"
// call: "casadi::IMatrix::zeros(x0_)"
// params: [CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__zeros__2(std::string ** err_msg, int x0);
casadi::IMatrix* casadi__IMatrix__zeros__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "zeros" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::zeros"
// cWrapperName: "casadi__IMatrix__zeros__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__IMatrix__zeros__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::IMatrix::zeros(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::IMatrix* casadi__IMatrix__zeros__3(std::string ** err_msg, int x0, int x1);
casadi::IMatrix* casadi__IMatrix__zeros__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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



// ================== delete UserType (Namespace ["casadi"]) (Name "IOScheme")===============
// classType: UserType (Namespace ["casadi"]) (Name "IOScheme")
extern "C"
    void delete_casadi__IOScheme(casadi::IOScheme* obj);
void delete_casadi__IOScheme(casadi::IOScheme* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0)"
// call: "casadi::IOScheme(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1)"
// call: "casadi::IOScheme(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__1(std::string ** err_msg, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2)"
// call: "casadi::IOScheme(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__2(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__3(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__4(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::string*>::marshal(x2);
        std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
        std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__5(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__6"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__6(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__7"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// params: [Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__7(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__8"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0, 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::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_)"
// params: [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)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6, std::string* x7, std::string* x8);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__8(std::string ** err_msg, std::string* x0, 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::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__9"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0, 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::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_)"
// params: [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)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0, 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);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__9(std::string ** err_msg, std::string* x0, 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::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__10"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__10(std::string ** err_msg, std::string* x0, 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::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_)"
// params: [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)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__10(std::string ** err_msg, std::string* x0, 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);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__10(std::string ** err_msg, std::string* x0, 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::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__11"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__11(std::string ** err_msg, std::string* x0, 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::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_)"
// params: [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)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__11(std::string ** err_msg, std::string* x0, 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);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__11(std::string ** err_msg, std::string* x0, 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::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__12"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__12(std::string ** err_msg, std::string* x0, 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::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_)"
// params: [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)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__12(std::string ** err_msg, std::string* x0, 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);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__12(std::string ** err_msg, std::string* x0, 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::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__13"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__13(std::string ** err_msg, std::string* x0, 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::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_)"
// params: [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),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__13(std::string ** err_msg, std::string* x0, 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);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__13(std::string ** err_msg, std::string* x0, 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::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__14"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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::string* x14)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__14(std::string ** err_msg, std::string* x0, 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::string* x14)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_)"
// params: [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),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__14(std::string ** err_msg, std::string* x0, 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::string* x14);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__14(std::string ** err_msg, std::string* x0, 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::string* x14){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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::string x14_ = Marshaling<std::string,std::string*>::marshal(x14);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__15"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__15(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_)"
// params: [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),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__15(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__15(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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::string x14_ = Marshaling<std::string,std::string*>::marshal(x14);
        std::string x15_ = Marshaling<std::string,std::string*>::marshal(x15);

        casadi::IOScheme ret = casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_);
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__16"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__16(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_)"
// params: [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),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__16(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__16(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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::string x14_ = Marshaling<std::string,std::string*>::marshal(x14);
        std::string x15_ = Marshaling<std::string,std::string*>::marshal(x15);
        std::string x16_ = Marshaling<std::string,std::string*>::marshal(x16);

        casadi::IOScheme ret = casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_);
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__17"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__17(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_)"
// params: [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),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__17(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__17(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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::string x14_ = Marshaling<std::string,std::string*>::marshal(x14);
        std::string x15_ = Marshaling<std::string,std::string*>::marshal(x15);
        std::string x16_ = Marshaling<std::string,std::string*>::marshal(x16);
        std::string x17_ = Marshaling<std::string,std::string*>::marshal(x17);

        casadi::IOScheme ret = casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_);
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__18"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__18(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_)"
// params: [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),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__18(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__18(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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::string x14_ = Marshaling<std::string,std::string*>::marshal(x14);
        std::string x15_ = Marshaling<std::string,std::string*>::marshal(x15);
        std::string x16_ = Marshaling<std::string,std::string*>::marshal(x16);
        std::string x17_ = Marshaling<std::string,std::string*>::marshal(x17);
        std::string x18_ = Marshaling<std::string,std::string*>::marshal(x18);

        casadi::IOScheme ret = casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_);
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__19"
// protoArgs: "(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18, std::string* x19)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_, x19_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__19(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18, std::string* x19)"
// call: "casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_, x19_)"
// params: [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),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__19(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18, std::string* x19);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__19(std::string ** err_msg, std::string* x0, 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::string* x14, std::string* x15, std::string* x16, std::string* x17, std::string* x18, std::string* x19){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        std::string x2_ = Marshaling<std::string,std::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::string x14_ = Marshaling<std::string,std::string*>::marshal(x14);
        std::string x15_ = Marshaling<std::string,std::string*>::marshal(x15);
        std::string x16_ = Marshaling<std::string,std::string*>::marshal(x16);
        std::string x17_ = Marshaling<std::string,std::string*>::marshal(x17);
        std::string x18_ = Marshaling<std::string,std::string*>::marshal(x18);
        std::string x19_ = Marshaling<std::string,std::string*>::marshal(x19);

        casadi::IOScheme ret = casadi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_, x19_);
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__20"
// protoArgs: "(std::string ** err_msg, std::vector< std::string* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__20(std::string ** err_msg, std::vector< std::string* >* x0)"
// call: "casadi::IOScheme(x0_)"
// params: [Ref (Const (StdVec StdString))]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__20(std::string ** err_msg, std::vector< std::string* >* x0);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__20(std::string ** err_msg, std::vector< std::string* >* x0){
    try {
        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__21"
// protoArgs: "(std::string ** err_msg, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__21(std::string ** err_msg, std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
// call: "casadi::IOScheme(x0_, x1_)"
// params: [Ref (Const (StdVec StdString)),Ref (Const (StdVec StdString))]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__21(std::string ** err_msg, std::vector< std::string* >* x0, std::vector< std::string* >* x1);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__21(std::string ** err_msg, std::vector< std::string* >* x0, std::vector< std::string* >* x1){
    try {
        std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);
        std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__22"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__22(std::string ** err_msg, int x0)"
// call: "casadi::IOScheme(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "InputOutputScheme")]
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__22(std::string ** err_msg, int x0);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__22(std::string ** err_msg, int x0){
    try {
        casadi::InputOutputScheme x0_ = Marshaling<casadi::InputOutputScheme,int>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme"
// cWrapperName: "casadi__IOScheme__CONSTRUCTOR__23"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__23(std::string ** err_msg)"
// call: "casadi::IOScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__23(std::string ** err_msg);
casadi::IOScheme* casadi__IOScheme__CONSTRUCTOR__23(std::string ** err_msg){
    try {

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


// ================== Normal method: "compatibleSize" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::compatibleSize"
// cWrapperName: "casadi__IOScheme__compatibleSize"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOScheme__compatibleSize(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->compatibleSize(x0_)"
// params: [CInt]
extern "C"
    int casadi__IOScheme__compatibleSize(std::string ** err_msg, casadi::IOScheme* obj, int x0);
int casadi__IOScheme__compatibleSize(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "describe" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::describe"
// cWrapperName: "casadi__IOScheme__describe"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__describe(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->describe(x0_)"
// params: [CInt]
extern "C"
    std::string* casadi__IOScheme__describe(std::string ** err_msg, casadi::IOScheme* obj, int x0);
std::string* casadi__IOScheme__describe(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "describeInput" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::describeInput"
// cWrapperName: "casadi__IOScheme__describeInput"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__describeInput(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->describeInput(x0_)"
// params: [CInt]
extern "C"
    std::string* casadi__IOScheme__describeInput(std::string ** err_msg, casadi::IOScheme* obj, int x0);
std::string* casadi__IOScheme__describeInput(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "describeOutput" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::describeOutput"
// cWrapperName: "casadi__IOScheme__describeOutput"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__describeOutput(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->describeOutput(x0_)"
// params: [CInt]
extern "C"
    std::string* casadi__IOScheme__describeOutput(std::string ** err_msg, casadi::IOScheme* obj, int x0);
std::string* casadi__IOScheme__describeOutput(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "entry" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::entry"
// cWrapperName: "casadi__IOScheme__entry"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__entry(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->entry(x0_)"
// params: [CInt]
extern "C"
    std::string* casadi__IOScheme__entry(std::string ** err_msg, casadi::IOScheme* obj, int x0);
std::string* casadi__IOScheme__entry(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "entryEnum" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::entryEnum"
// cWrapperName: "casadi__IOScheme__entryEnum"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__entryEnum(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->entryEnum(x0_)"
// params: [CInt]
extern "C"
    std::string* casadi__IOScheme__entryEnum(std::string ** err_msg, casadi::IOScheme* obj, int x0);
std::string* casadi__IOScheme__entryEnum(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "entryLabel" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::entryLabel"
// cWrapperName: "casadi__IOScheme__entryLabel"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__entryLabel(std::string ** err_msg, casadi::IOScheme* obj, int x0)"
// call: "obj->entryLabel(x0_)"
// params: [CInt]
extern "C"
    std::string* casadi__IOScheme__entryLabel(std::string ** err_msg, casadi::IOScheme* obj, int x0);
std::string* casadi__IOScheme__entryLabel(std::string ** err_msg, casadi::IOScheme* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "entryNames" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::entryNames"
// cWrapperName: "casadi__IOScheme__entryNames"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__entryNames(std::string ** err_msg, casadi::IOScheme* obj)"
// call: "obj->entryNames()"
// params: []
extern "C"
    std::string* casadi__IOScheme__entryNames(std::string ** err_msg, casadi::IOScheme* obj);
std::string* casadi__IOScheme__entryNames(std::string ** err_msg, casadi::IOScheme* obj){
    try {

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


// ================== Normal method: "index" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::index"
// cWrapperName: "casadi__IOScheme__index"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOScheme__index(std::string ** err_msg, casadi::IOScheme* obj, std::string* x0)"
// call: "obj->index(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__IOScheme__index(std::string ** err_msg, casadi::IOScheme* obj, std::string* x0);
int casadi__IOScheme__index(std::string ** err_msg, casadi::IOScheme* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "known" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::known"
// cWrapperName: "casadi__IOScheme__known"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__IOScheme__known(std::string ** err_msg, casadi::IOScheme* obj)"
// call: "obj->known()"
// params: []
extern "C"
    int casadi__IOScheme__known(std::string ** err_msg, casadi::IOScheme* obj);
int casadi__IOScheme__known(std::string ** err_msg, casadi::IOScheme* obj){
    try {

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


// ================== Normal method: "name" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::name"
// cWrapperName: "casadi__IOScheme__name"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IOScheme__name(std::string ** err_msg, casadi::IOScheme* obj)"
// call: "obj->name()"
// params: []
extern "C"
    std::string* casadi__IOScheme__name(std::string ** err_msg, casadi::IOScheme* obj);
std::string* casadi__IOScheme__name(std::string ** err_msg, casadi::IOScheme* obj){
    try {

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


// ================== Normal method: "size" ===============
// class: "casadi::IOScheme"
// cppName: "casadi::IOScheme::size"
// cWrapperName: "casadi__IOScheme__size"
// protoArgs: "(std::string ** err_msg, casadi::IOScheme* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOScheme__size(std::string ** err_msg, casadi::IOScheme* obj)"
// call: "obj->size()"
// params: []
extern "C"
    int casadi__IOScheme__size(std::string ** err_msg, casadi::IOScheme* obj);
int casadi__IOScheme__size(std::string ** err_msg, casadi::IOScheme* obj){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "ImplicitFunction")===============
// classType: UserType (Namespace ["casadi"]) (Name "ImplicitFunction")
extern "C"
    void delete_casadi__ImplicitFunction(casadi::ImplicitFunction* obj);
void delete_casadi__ImplicitFunction(casadi::ImplicitFunction* obj){
    delete obj;
}

// ================== Normal method: "getF" ===============
// class: "casadi::ImplicitFunction"
// cppName: "casadi::ImplicitFunction::getF"
// cWrapperName: "casadi__ImplicitFunction__getF"
// protoArgs: "(std::string ** err_msg, casadi::ImplicitFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__ImplicitFunction__getF(std::string ** err_msg, casadi::ImplicitFunction* obj)"
// call: "obj->getF()"
// params: []
extern "C"
    casadi::Function* casadi__ImplicitFunction__getF(std::string ** err_msg, casadi::ImplicitFunction* obj);
casadi::Function* casadi__ImplicitFunction__getF(std::string ** err_msg, casadi::ImplicitFunction* obj){
    try {

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


// ================== Normal method: "getJac" ===============
// class: "casadi::ImplicitFunction"
// cppName: "casadi::ImplicitFunction::getJac"
// cWrapperName: "casadi__ImplicitFunction__getJac"
// protoArgs: "(std::string ** err_msg, casadi::ImplicitFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__ImplicitFunction__getJac(std::string ** err_msg, casadi::ImplicitFunction* obj)"
// call: "obj->getJac()"
// params: []
extern "C"
    casadi::Function* casadi__ImplicitFunction__getJac(std::string ** err_msg, casadi::ImplicitFunction* obj);
casadi::Function* casadi__ImplicitFunction__getJac(std::string ** err_msg, casadi::ImplicitFunction* obj){
    try {

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


// ================== Normal method: "getLinsol" ===============
// class: "casadi::ImplicitFunction"
// cppName: "casadi::ImplicitFunction::getLinsol"
// cWrapperName: "casadi__ImplicitFunction__getLinsol"
// protoArgs: "(std::string ** err_msg, casadi::ImplicitFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
// cWrapperRetType: "casadi::LinearSolver*"
// proto: "casadi::LinearSolver* casadi__ImplicitFunction__getLinsol(std::string ** err_msg, casadi::ImplicitFunction* obj)"
// call: "obj->getLinsol()"
// params: []
extern "C"
    casadi::LinearSolver* casadi__ImplicitFunction__getLinsol(std::string ** err_msg, casadi::ImplicitFunction* obj);
casadi::LinearSolver* casadi__ImplicitFunction__getLinsol(std::string ** err_msg, casadi::ImplicitFunction* obj){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "Integrator")===============
// classType: UserType (Namespace ["casadi"]) (Name "Integrator")
extern "C"
    void delete_casadi__Integrator(casadi::Integrator* obj);
void delete_casadi__Integrator(casadi::Integrator* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator"
// cWrapperName: "casadi__Integrator__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
// cWrapperRetType: "casadi::Integrator*"
// proto: "casadi::Integrator* casadi__Integrator__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::Integrator()"
// params: []
extern "C"
    casadi::Integrator* casadi__Integrator__CONSTRUCTOR(std::string ** err_msg);
casadi::Integrator* casadi__Integrator__CONSTRUCTOR(std::string ** err_msg){
    try {

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


// ================== Normal method: "clone" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::clone"
// cWrapperName: "casadi__Integrator__clone"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
// cWrapperRetType: "casadi::Integrator*"
// proto: "casadi::Integrator* casadi__Integrator__clone(std::string ** err_msg, casadi::Integrator* obj)"
// call: "obj->clone()"
// params: []
extern "C"
    casadi::Integrator* casadi__Integrator__clone(std::string ** err_msg, casadi::Integrator* obj);
casadi::Integrator* casadi__Integrator__clone(std::string ** err_msg, casadi::Integrator* obj){
    try {

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


// ================== Normal method: "getDAE" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::getDAE"
// cWrapperName: "casadi__Integrator__getDAE"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__Integrator__getDAE(std::string ** err_msg, casadi::Integrator* obj)"
// call: "obj->getDAE()"
// params: []
extern "C"
    casadi::Function* casadi__Integrator__getDAE(std::string ** err_msg, casadi::Integrator* obj);
casadi::Function* casadi__Integrator__getDAE(std::string ** err_msg, casadi::Integrator* obj){
    try {

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


// ================== Normal method: "integrate" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::integrate"
// cWrapperName: "casadi__Integrator__integrate"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Integrator__integrate(std::string ** err_msg, casadi::Integrator* obj, double x0)"
// call: "obj->integrate(x0_)"
// params: [CDouble]
extern "C"
    void casadi__Integrator__integrate(std::string ** err_msg, casadi::Integrator* obj, double x0);
void casadi__Integrator__integrate(std::string ** err_msg, casadi::Integrator* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->integrate(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "integrateB" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::integrateB"
// cWrapperName: "casadi__Integrator__integrateB"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Integrator__integrateB(std::string ** err_msg, casadi::Integrator* obj, double x0)"
// call: "obj->integrateB(x0_)"
// params: [CDouble]
extern "C"
    void casadi__Integrator__integrateB(std::string ** err_msg, casadi::Integrator* obj, double x0);
void casadi__Integrator__integrateB(std::string ** err_msg, casadi::Integrator* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->integrateB(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printStats" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::printStats"
// cWrapperName: "casadi__Integrator__printStats"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Integrator__printStats(std::string ** err_msg, casadi::Integrator* obj)"
// call: "obj->printStats()"
// params: []
extern "C"
    void casadi__Integrator__printStats(std::string ** err_msg, casadi::Integrator* obj);
void casadi__Integrator__printStats(std::string ** err_msg, casadi::Integrator* obj){
    try {

    obj->printStats();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reset" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::reset"
// cWrapperName: "casadi__Integrator__reset"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Integrator__reset(std::string ** err_msg, casadi::Integrator* obj)"
// call: "obj->reset()"
// params: []
extern "C"
    void casadi__Integrator__reset(std::string ** err_msg, casadi::Integrator* obj);
void casadi__Integrator__reset(std::string ** err_msg, casadi::Integrator* obj){
    try {

    obj->reset();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "resetB" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator::resetB"
// cWrapperName: "casadi__Integrator__resetB"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Integrator__resetB(std::string ** err_msg, casadi::Integrator* obj)"
// call: "obj->resetB()"
// params: []
extern "C"
    void casadi__Integrator__resetB(std::string ** err_msg, casadi::Integrator* obj);
void casadi__Integrator__resetB(std::string ** err_msg, casadi::Integrator* obj){
    try {

    obj->resetB();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "LPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "LPSolver")
extern "C"
    void delete_casadi__LPSolver(casadi::LPSolver* obj);
void delete_casadi__LPSolver(casadi::LPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::LPSolver"
// cppName: "casadi::LPSolver"
// cWrapperName: "casadi__LPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "LPSolver")
// cWrapperRetType: "casadi::LPSolver*"
// proto: "casadi::LPSolver* casadi__LPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::LPSolver()"
// params: []
extern "C"
    casadi::LPSolver* casadi__LPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::LPSolver* casadi__LPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

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



// ================== delete UserType (Namespace ["casadi"]) (Name "LinearSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "LinearSolver")
extern "C"
    void delete_casadi__LinearSolver(casadi::LinearSolver* obj);
void delete_casadi__LinearSolver(casadi::LinearSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver"
// cWrapperName: "casadi__LinearSolver__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
// cWrapperRetType: "casadi::LinearSolver*"
// proto: "casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::LinearSolver(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver"
// cWrapperName: "casadi__LinearSolver__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
// cWrapperRetType: "casadi::LinearSolver*"
// proto: "casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__1(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// call: "casadi::LinearSolver(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__1(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__1(std::string ** err_msg, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "prepare" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver::prepare"
// cWrapperName: "casadi__LinearSolver__prepare"
// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__LinearSolver__prepare(std::string ** err_msg, casadi::LinearSolver* obj)"
// call: "obj->prepare()"
// params: []
extern "C"
    void casadi__LinearSolver__prepare(std::string ** err_msg, casadi::LinearSolver* obj);
void casadi__LinearSolver__prepare(std::string ** err_msg, casadi::LinearSolver* obj){
    try {

    obj->prepare();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "prepared" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver::prepared"
// cWrapperName: "casadi__LinearSolver__prepared"
// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__LinearSolver__prepared(std::string ** err_msg, casadi::LinearSolver* obj)"
// call: "obj->prepared()"
// params: []
extern "C"
    int casadi__LinearSolver__prepared(std::string ** err_msg, casadi::LinearSolver* obj);
int casadi__LinearSolver__prepared(std::string ** err_msg, casadi::LinearSolver* obj){
    try {

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


// ================== Normal method: "solve" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver::solve"
// cWrapperName: "casadi__LinearSolver__solve__0"
// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__LinearSolver__solve__0(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1)"
// call: "obj->solve(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__LinearSolver__solve__0(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1);
casadi::MX* casadi__LinearSolver__solve__0(std::string ** err_msg, casadi::LinearSolver* obj, 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 = obj->solve(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "solve" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver::solve"
// cWrapperName: "casadi__LinearSolver__solve__1"
// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__LinearSolver__solve__1(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2)"
// call: "obj->solve(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CBool]
extern "C"
    casadi::MX* casadi__LinearSolver__solve__1(std::string ** err_msg, casadi::LinearSolver* obj, casadi::MX* x0, casadi::MX* x1, int x2);
casadi::MX* casadi__LinearSolver__solve__1(std::string ** err_msg, casadi::LinearSolver* obj, 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);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

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


// ================== Normal method: "solve" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver::solve"
// cWrapperName: "casadi__LinearSolver__solve__2"
// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__LinearSolver__solve__2(std::string ** err_msg, casadi::LinearSolver* obj)"
// call: "obj->solve()"
// params: []
extern "C"
    void casadi__LinearSolver__solve__2(std::string ** err_msg, casadi::LinearSolver* obj);
void casadi__LinearSolver__solve__2(std::string ** err_msg, casadi::LinearSolver* obj){
    try {

    obj->solve();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "solve" ===============
// class: "casadi::LinearSolver"
// cppName: "casadi::LinearSolver::solve"
// cWrapperName: "casadi__LinearSolver__solve__3"
// protoArgs: "(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__LinearSolver__solve__3(std::string ** err_msg, casadi::LinearSolver* obj, int x0)"
// call: "obj->solve(x0_)"
// params: [CBool]
extern "C"
    void casadi__LinearSolver__solve__3(std::string ** err_msg, casadi::LinearSolver* obj, int x0);
void casadi__LinearSolver__solve__3(std::string ** err_msg, casadi::LinearSolver* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->solve(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "MX")===============
// classType: UserType (Namespace ["casadi"]) (Name "MX")
extern "C"
    void delete_casadi__MX(casadi::MX* obj);
void delete_casadi__MX(casadi::MX* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::MX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DMatrix* x0);
casadi::MX* casadi__MX__CONSTRUCTOR__0(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::MX(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0);
casadi::MX* casadi__MX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0)"
// call: "casadi::MX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0);
casadi::MX* casadi__MX__CONSTRUCTOR__2(std::string ** err_msg, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0)"
// call: "casadi::MX(x0_)"
// params: [CDouble]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0);
casadi::MX* casadi__MX__CONSTRUCTOR__3(std::string ** err_msg, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1)"
// call: "casadi::MX(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1);
casadi::MX* casadi__MX__CONSTRUCTOR__4(std::string ** err_msg, casadi::Sparsity* x0, casadi::MX* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0, double x1)"
// call: "casadi::MX(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CDouble]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0, double x1);
casadi::MX* casadi__MX__CONSTRUCTOR__5(std::string ** err_msg, casadi::Sparsity* x0, double x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__6"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::MX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0);
casadi::MX* casadi__MX__CONSTRUCTOR__6(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__7"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// call: "casadi::MX(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::MX* casadi__MX__CONSTRUCTOR__7(std::string ** err_msg, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MX"
// cppName: "casadi::MX"
// cWrapperName: "casadi__MX__CONSTRUCTOR__8"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__CONSTRUCTOR__8(std::string ** err_msg)"
// call: "casadi::MX()"
// params: []
extern "C"
    casadi::MX* casadi__MX__CONSTRUCTOR__8(std::string ** err_msg);
casadi::MX* casadi__MX__CONSTRUCTOR__8(std::string ** err_msg){
    try {

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


// ================== Normal method: "__add__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__add__"
// cWrapperName: "casadi__MX____add__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____add__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__add__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____add__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____add__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__constpow__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__constpow__"
// cWrapperName: "casadi__MX____constpow__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____constpow__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__constpow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____constpow__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____constpow__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__copysign__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__copysign__"
// cWrapperName: "casadi__MX____copysign__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____copysign__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__copysign__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____copysign__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____copysign__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__div__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__div__"
// cWrapperName: "casadi__MX____div__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____div__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__div__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____div__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____div__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__eq__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__eq__"
// cWrapperName: "casadi__MX____eq__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____eq__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__eq__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____eq__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____eq__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__ge__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__ge__"
// cWrapperName: "casadi__MX____ge__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____ge__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__ge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____ge__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____ge__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__gt__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__gt__"
// cWrapperName: "casadi__MX____gt__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____gt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__gt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____gt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____gt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__hash__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__hash__"
// cWrapperName: "casadi__MX____hash__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long casadi__MX____hash__(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->__hash__()"
// params: []
extern "C"
    long casadi__MX____hash__(std::string ** err_msg, casadi::MX* obj);
long casadi__MX____hash__(std::string ** err_msg, casadi::MX* obj){
    try {

        long ret = obj->__hash__();
        return WrapReturn< long, long >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__le__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__le__"
// cWrapperName: "casadi__MX____le__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____le__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__le__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____le__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____le__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__lt__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__lt__"
// cWrapperName: "casadi__MX____lt__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____lt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__lt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____lt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____lt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__mldivide__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__mldivide__"
// cWrapperName: "casadi__MX____mldivide__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____mldivide__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__mldivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____mldivide__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____mldivide__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__mpower__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__mpower__"
// cWrapperName: "casadi__MX____mpower__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____mpower__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__mpower__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____mpower__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____mpower__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__mrdivide__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__mrdivide__"
// cWrapperName: "casadi__MX____mrdivide__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____mrdivide__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__mrdivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____mrdivide__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____mrdivide__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__mul__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__mul__"
// cWrapperName: "casadi__MX____mul__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____mul__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__mul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____mul__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____mul__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__ne__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__ne__"
// cWrapperName: "casadi__MX____ne__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____ne__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__ne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____ne__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____ne__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__nonzero__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__nonzero__"
// cWrapperName: "casadi__MX____nonzero__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->__nonzero__()"
// params: []
extern "C"
    int casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj);
int casadi__MX____nonzero__(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "__pow__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__pow__"
// cWrapperName: "casadi__MX____pow__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____pow__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__pow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____pow__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____pow__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__radd__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__radd__"
// cWrapperName: "casadi__MX____radd__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____radd__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__radd__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____radd__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____radd__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rdiv__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rdiv__"
// cWrapperName: "casadi__MX____rdiv__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rdiv__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rdiv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rdiv__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rdiv__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__req__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__req__"
// cWrapperName: "casadi__MX____req__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____req__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__req__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____req__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____req__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rge__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rge__"
// cWrapperName: "casadi__MX____rge__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rge__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rge__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rge__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rgt__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rgt__"
// cWrapperName: "casadi__MX____rgt__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rgt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rgt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rgt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rgt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rle__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rle__"
// cWrapperName: "casadi__MX____rle__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rle__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rle__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rle__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rle__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rlt__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rlt__"
// cWrapperName: "casadi__MX____rlt__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rlt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rlt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rlt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rlt__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rmul__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rmul__"
// cWrapperName: "casadi__MX____rmul__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rmul__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rmul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rmul__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rmul__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rne__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rne__"
// cWrapperName: "casadi__MX____rne__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rne__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rne__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rne__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rsub__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rsub__"
// cWrapperName: "casadi__MX____rsub__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rsub__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rsub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rsub__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rsub__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__rtruediv__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__rtruediv__"
// cWrapperName: "casadi__MX____rtruediv__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____rtruediv__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__rtruediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____rtruediv__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____rtruediv__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__sub__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__sub__"
// cWrapperName: "casadi__MX____sub__"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____sub__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__sub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____sub__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____sub__(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__truediv__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__truediv__"
// cWrapperName: "casadi__MX____truediv____0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____truediv____0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____truediv____0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____truediv____0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "__truediv__" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::__truediv__"
// cWrapperName: "casadi__MX____truediv____1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX____truediv____1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX____truediv____1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX____truediv____1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "addToSum" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::addToSum"
// cWrapperName: "casadi__MX__addToSum"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__addToSum(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->addToSum(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__addToSum(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
void casadi__MX__addToSum(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    obj->addToSum(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "append" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::append"
// cWrapperName: "casadi__MX__append"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__append(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->append(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__append(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
void casadi__MX__append(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    obj->append(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "appendColumns" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::appendColumns"
// cWrapperName: "casadi__MX__appendColumns"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__appendColumns(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->appendColumns(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__appendColumns(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
void casadi__MX__appendColumns(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    obj->appendColumns(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "arccos" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arccos"
// cWrapperName: "casadi__MX__arccos"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arccos(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->arccos()"
// params: []
extern "C"
    casadi::MX* casadi__MX__arccos(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__arccos(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "arccosh" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arccosh"
// cWrapperName: "casadi__MX__arccosh"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arccosh(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->arccosh()"
// params: []
extern "C"
    casadi::MX* casadi__MX__arccosh(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__arccosh(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "arcsin" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arcsin"
// cWrapperName: "casadi__MX__arcsin"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arcsin(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->arcsin()"
// params: []
extern "C"
    casadi::MX* casadi__MX__arcsin(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__arcsin(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "arcsinh" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arcsinh"
// cWrapperName: "casadi__MX__arcsinh"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arcsinh(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->arcsinh()"
// params: []
extern "C"
    casadi::MX* casadi__MX__arcsinh(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__arcsinh(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "arctan" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arctan"
// cWrapperName: "casadi__MX__arctan"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arctan(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->arctan()"
// params: []
extern "C"
    casadi::MX* casadi__MX__arctan(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__arctan(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "arctan2" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arctan2"
// cWrapperName: "casadi__MX__arctan2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arctan2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->arctan2(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__arctan2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__arctan2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "arctanh" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::arctanh"
// cWrapperName: "casadi__MX__arctanh"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__arctanh(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->arctanh()"
// params: []
extern "C"
    casadi::MX* casadi__MX__arctanh(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__arctanh(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "attachAssert" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::attachAssert"
// cWrapperName: "casadi__MX__attachAssert__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->attachAssert(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__attachAssert__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "attachAssert" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::attachAssert"
// cWrapperName: "casadi__MX__attachAssert__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1)"
// call: "obj->attachAssert(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1);
casadi::MX* casadi__MX__attachAssert__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::string* x1){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

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


// ================== Static method: "binary" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::binary"
// cWrapperName: "casadi__MX__binary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2)"
// call: "casadi::MX::binary(x0_, x1_, x2_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2);
casadi::MX* casadi__MX__binary(std::string ** err_msg, int x0, casadi::MX* x1, casadi::MX* x2){
    try {
        int x0_ = Marshaling<int,int>::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::MX::binary(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "ceil" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::ceil"
// cWrapperName: "casadi__MX__ceil"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__ceil(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->ceil()"
// params: []
extern "C"
    casadi::MX* casadi__MX__ceil(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__ceil(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "constpow" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::constpow"
// cWrapperName: "casadi__MX__constpow"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__constpow(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->constpow(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__constpow(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__constpow(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "cos" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::cos"
// cWrapperName: "casadi__MX__cos"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__cos(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->cos()"
// params: []
extern "C"
    casadi::MX* casadi__MX__cos(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__cos(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "cosh" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::cosh"
// cWrapperName: "casadi__MX__cosh"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__cosh(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->cosh()"
// params: []
extern "C"
    casadi::MX* casadi__MX__cosh(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__cosh(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "densify" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::densify"
// cWrapperName: "casadi__MX__densify__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__densify__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->densify()"
// params: []
extern "C"
    void casadi__MX__densify__0(std::string ** err_msg, casadi::MX* obj);
void casadi__MX__densify__0(std::string ** err_msg, casadi::MX* obj){
    try {

    obj->densify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "densify" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::densify"
// cWrapperName: "casadi__MX__densify__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__densify__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->densify(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__densify__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
void casadi__MX__densify__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    obj->densify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "dimString" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::dimString"
// cWrapperName: "casadi__MX__dimString"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__MX__dimString(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->dimString()"
// params: []
extern "C"
    std::string* casadi__MX__dimString(std::string ** err_msg, casadi::MX* obj);
std::string* casadi__MX__dimString(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "enlarge" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::enlarge"
// cWrapperName: "casadi__MX__enlarge"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__enlarge(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__MX__enlarge(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void casadi__MX__enlarge(std::string ** err_msg, casadi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

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


// ================== Normal method: "erase" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::erase"
// cWrapperName: "casadi__MX__erase"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__erase(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__MX__erase(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__MX__erase(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->erase(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "erf" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::erf"
// cWrapperName: "casadi__MX__erf"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__erf(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->erf()"
// params: []
extern "C"
    casadi::MX* casadi__MX__erf(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__erf(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "erfinv" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::erfinv"
// cWrapperName: "casadi__MX__erfinv"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__erfinv(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->erfinv()"
// params: []
extern "C"
    casadi::MX* casadi__MX__erfinv(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__erfinv(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "exp" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::exp"
// cWrapperName: "casadi__MX__exp"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__exp(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->exp()"
// params: []
extern "C"
    casadi::MX* casadi__MX__exp(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__exp(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Static method: "eye" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::eye"
// cWrapperName: "casadi__MX__eye"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__eye(std::string ** err_msg, int x0)"
// call: "casadi::MX::eye(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__eye(std::string ** err_msg, int x0);
casadi::MX* casadi__MX__eye(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "fabs" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::fabs"
// cWrapperName: "casadi__MX__fabs"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__fabs(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->fabs()"
// params: []
extern "C"
    casadi::MX* casadi__MX__fabs(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__fabs(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "floor" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::floor"
// cWrapperName: "casadi__MX__floor"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__floor(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->floor()"
// params: []
extern "C"
    casadi::MX* casadi__MX__floor(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__floor(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "fmax" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::fmax"
// cWrapperName: "casadi__MX__fmax"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__fmax(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->fmax(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__fmax(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__fmax(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "fmin" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::fmin"
// cWrapperName: "casadi__MX__fmin"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__fmin(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->fmin(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__fmin(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__fmin(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "fmod" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::fmod"
// cWrapperName: "casadi__MX__fmod"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__fmod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->fmod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__fmod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__fmod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "getDep" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getDep"
// cWrapperName: "casadi__MX__getDep__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getDep__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getDep()"
// params: []
extern "C"
    casadi::MX* casadi__MX__getDep__0(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__getDep__0(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getDep" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getDep"
// cWrapperName: "casadi__MX__getDep__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getDep__1(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->getDep(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__getDep__1(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__getDep__1(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getEqualityCheckingDepth"
// cWrapperName: "casadi__MX__getEqualityCheckingDepth"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__getEqualityCheckingDepth(std::string ** err_msg)"
// call: "casadi::MX::getEqualityCheckingDepth()"
// params: []
extern "C"
    int casadi__MX__getEqualityCheckingDepth(std::string ** err_msg);
int casadi__MX__getEqualityCheckingDepth(std::string ** err_msg){
    try {

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


// ================== Normal method: "getEvaluationOutput" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getEvaluationOutput"
// cWrapperName: "casadi__MX__getEvaluationOutput"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__getEvaluationOutput(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getEvaluationOutput()"
// params: []
extern "C"
    int casadi__MX__getEvaluationOutput(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__getEvaluationOutput(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getFunction" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getFunction"
// cWrapperName: "casadi__MX__getFunction"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__MX__getFunction(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getFunction()"
// params: []
extern "C"
    casadi::Function* casadi__MX__getFunction(std::string ** err_msg, casadi::MX* obj);
casadi::Function* casadi__MX__getFunction(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getMatrixValue" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getMatrixValue"
// cWrapperName: "casadi__MX__getMatrixValue"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__MX__getMatrixValue(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getMatrixValue()"
// params: []
extern "C"
    casadi::DMatrix* casadi__MX__getMatrixValue(std::string ** err_msg, casadi::MX* obj);
casadi::DMatrix* casadi__MX__getMatrixValue(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getMaxNumCallsInPrint"
// cWrapperName: "casadi__MX__getMaxNumCallsInPrint"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long casadi__MX__getMaxNumCallsInPrint(std::string ** err_msg)"
// call: "casadi::MX::getMaxNumCallsInPrint()"
// params: []
extern "C"
    long casadi__MX__getMaxNumCallsInPrint(std::string ** err_msg);
long casadi__MX__getMaxNumCallsInPrint(std::string ** err_msg){
    try {

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getNZ"
// cWrapperName: "casadi__MX__getNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__getNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0);
casadi::MX* casadi__MX__getNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getNZ"
// cWrapperName: "casadi__MX__getNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__getNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0);
casadi::MX* casadi__MX__getNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getNZ"
// cWrapperName: "casadi__MX__getNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getNZ__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::MX* casadi__MX__getNZ__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0);
casadi::MX* casadi__MX__getNZ__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

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


// ================== Normal method: "getNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getNZ"
// cWrapperName: "casadi__MX__getNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getNZ__3(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->getNZ(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__getNZ__3(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__getNZ__3(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "getName" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getName"
// cWrapperName: "casadi__MX__getName"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__MX__getName(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getName()"
// params: []
extern "C"
    std::string* casadi__MX__getName(std::string ** err_msg, casadi::MX* obj);
std::string* casadi__MX__getName(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getNdeps" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getNdeps"
// cWrapperName: "casadi__MX__getNdeps"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__getNdeps(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getNdeps()"
// params: []
extern "C"
    int casadi__MX__getNdeps(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__getNdeps(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getNumOutputs" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getNumOutputs"
// cWrapperName: "casadi__MX__getNumOutputs"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__getNumOutputs(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getNumOutputs()"
// params: []
extern "C"
    int casadi__MX__getNumOutputs(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__getNumOutputs(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getOp" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getOp"
// cWrapperName: "casadi__MX__getOp"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__getOp(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getOp()"
// params: []
extern "C"
    int casadi__MX__getOp(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__getOp(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getOutput" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getOutput"
// cWrapperName: "casadi__MX__getOutput__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getOutput()"
// params: []
extern "C"
    casadi::MX* casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__getOutput__0(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getOutput" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getOutput"
// cWrapperName: "casadi__MX__getOutput__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->getOutput(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__getOutput__1(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "getTemp" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getTemp"
// cWrapperName: "casadi__MX__getTemp"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getTemp()"
// params: []
extern "C"
    int casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__getTemp(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "getValue" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::getValue"
// cWrapperName: "casadi__MX__getValue"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__MX__getValue(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->getValue()"
// params: []
extern "C"
    double casadi__MX__getValue(std::string ** err_msg, casadi::MX* obj);
double casadi__MX__getValue(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "if_else_zero" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::if_else_zero"
// cWrapperName: "casadi__MX__if_else_zero"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__if_else_zero(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->if_else_zero(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__if_else_zero(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__if_else_zero(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__0(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__indexed__0(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0);
casadi::MX* casadi__MX__indexed__0(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__indexed__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::MX* casadi__MX__indexed__1(std::string ** err_msg, casadi::MX* obj, 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::MX ret = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__2(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__indexed__2(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::MX* casadi__MX__indexed__2(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__3(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__indexed__3(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::MX* casadi__MX__indexed__3(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__4"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__4(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__indexed__4(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0);
casadi::MX* casadi__MX__indexed__4(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__5"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__5(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__indexed__5(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0);
casadi::MX* casadi__MX__indexed__5(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed"
// cWrapperName: "casadi__MX__indexed__6"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed__6(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__indexed__6(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::MX* casadi__MX__indexed__6(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

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


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_assignment"
// cWrapperName: "casadi__MX__indexed_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_assignment__0(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_assignment__0(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1);
void casadi__MX__indexed_assignment__0(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_assignment"
// cWrapperName: "casadi__MX__indexed_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::MX* x2);
void casadi__MX__indexed_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::MX* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_assignment"
// cWrapperName: "casadi__MX__indexed_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_assignment__2(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_assignment__2(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::MX* x2);
void casadi__MX__indexed_assignment__2(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::MX* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_assignment"
// cWrapperName: "casadi__MX__indexed_assignment__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_assignment__3(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_assignment__3(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::MX* x2);
void casadi__MX__indexed_assignment__3(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::MX* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_assignment"
// cWrapperName: "casadi__MX__indexed_assignment__4"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_assignment__4(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, casadi::MX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_assignment__4(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, casadi::MX* x1);
void casadi__MX__indexed_assignment__4(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, casadi::MX* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_assignment"
// cWrapperName: "casadi__MX__indexed_assignment__5"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_assignment__5(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_assignment__5(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::MX* x2);
void casadi__MX__indexed_assignment__5(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::MX* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_one_based"
// cWrapperName: "casadi__MX__indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed_one_based__0(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__indexed_one_based__0(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__indexed_one_based__0(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_one_based"
// cWrapperName: "casadi__MX__indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed_one_based__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1)"
// call: "obj->indexed_one_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__indexed_one_based__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1);
casadi::MX* casadi__MX__indexed_one_based__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_one_based_assignment"
// cWrapperName: "casadi__MX__indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_one_based_assignment__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_one_based_assignment__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1);
void casadi__MX__indexed_one_based_assignment__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_one_based_assignment"
// cWrapperName: "casadi__MX__indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_one_based_assignment__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_one_based_assignment__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2);
void casadi__MX__indexed_one_based_assignment__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_zero_based"
// cWrapperName: "casadi__MX__indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed_zero_based__0(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__indexed_zero_based__0(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__indexed_zero_based__0(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_zero_based"
// cWrapperName: "casadi__MX__indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__indexed_zero_based__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1)"
// call: "obj->indexed_zero_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__indexed_zero_based__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1);
casadi::MX* casadi__MX__indexed_zero_based__1(std::string ** err_msg, casadi::MX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_zero_based_assignment"
// cWrapperName: "casadi__MX__indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1);
void casadi__MX__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_zero_based_assignment"
// cWrapperName: "casadi__MX__indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1);
void casadi__MX__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::indexed_zero_based_assignment"
// cWrapperName: "casadi__MX__indexed_zero_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2);
void casadi__MX__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::MX* obj, int x0, int x1, casadi::MX* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::MX x2_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::inf"
// cWrapperName: "casadi__MX__inf__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__inf__0(std::string ** err_msg)"
// call: "casadi::MX::inf()"
// params: []
extern "C"
    casadi::MX* casadi__MX__inf__0(std::string ** err_msg);
casadi::MX* casadi__MX__inf__0(std::string ** err_msg){
    try {

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


// ================== Static method: "inf" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::inf"
// cWrapperName: "casadi__MX__inf__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__inf__1(std::string ** err_msg, int x0)"
// call: "casadi::MX::inf(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__inf__1(std::string ** err_msg, int x0);
casadi::MX* casadi__MX__inf__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "inf" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::inf"
// cWrapperName: "casadi__MX__inf__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__inf__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::MX::inf(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__inf__2(std::string ** err_msg, int x0, int x1);
casadi::MX* casadi__MX__inf__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "inf" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::inf"
// cWrapperName: "casadi__MX__inf__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__inf__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::MX::inf(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__inf__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::MX* casadi__MX__inf__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "inner_prod" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::inner_prod"
// cWrapperName: "casadi__MX__inner_prod"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__inner_prod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->inner_prod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__inner_prod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__inner_prod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "isBinary" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isBinary"
// cWrapperName: "casadi__MX__isBinary"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isBinary(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isBinary()"
// params: []
extern "C"
    int casadi__MX__isBinary(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isBinary(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isCommutative" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isCommutative"
// cWrapperName: "casadi__MX__isCommutative"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isCommutative(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isCommutative()"
// params: []
extern "C"
    int casadi__MX__isCommutative(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isCommutative(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isConstant" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isConstant"
// cWrapperName: "casadi__MX__isConstant"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isConstant(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isConstant()"
// params: []
extern "C"
    int casadi__MX__isConstant(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isConstant(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isDense" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isDense"
// cWrapperName: "casadi__MX__isDense"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isDense(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isDense()"
// params: []
extern "C"
    int casadi__MX__isDense(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isDense(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isEmpty" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isEmpty"
// cWrapperName: "casadi__MX__isEmpty__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isEmpty__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isEmpty()"
// params: []
extern "C"
    int casadi__MX__isEmpty__0(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isEmpty__0(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isEmpty" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isEmpty"
// cWrapperName: "casadi__MX__isEmpty__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isEmpty__1(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->isEmpty(x0_)"
// params: [CBool]
extern "C"
    int casadi__MX__isEmpty__1(std::string ** err_msg, casadi::MX* obj, int x0);
int casadi__MX__isEmpty__1(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "isEqual" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isEqual"
// cWrapperName: "casadi__MX__isEqual__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isEqual__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->isEqual(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    int casadi__MX__isEqual__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
int casadi__MX__isEqual__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


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

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


// ================== Normal method: "isEvaluation" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isEvaluation"
// cWrapperName: "casadi__MX__isEvaluation"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isEvaluation(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isEvaluation()"
// params: []
extern "C"
    int casadi__MX__isEvaluation(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isEvaluation(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isEvaluationOutput" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isEvaluationOutput"
// cWrapperName: "casadi__MX__isEvaluationOutput"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isEvaluationOutput(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isEvaluationOutput()"
// params: []
extern "C"
    int casadi__MX__isEvaluationOutput(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isEvaluationOutput(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isIdentity" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isIdentity"
// cWrapperName: "casadi__MX__isIdentity"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isIdentity(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isIdentity()"
// params: []
extern "C"
    int casadi__MX__isIdentity(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isIdentity(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isMinusOne" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isMinusOne"
// cWrapperName: "casadi__MX__isMinusOne"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isMinusOne(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isMinusOne()"
// params: []
extern "C"
    int casadi__MX__isMinusOne(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isMinusOne(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isMultiplication" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isMultiplication"
// cWrapperName: "casadi__MX__isMultiplication"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isMultiplication(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isMultiplication()"
// params: []
extern "C"
    int casadi__MX__isMultiplication(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isMultiplication(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isNorm" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isNorm"
// cWrapperName: "casadi__MX__isNorm"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isNorm(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isNorm()"
// params: []
extern "C"
    int casadi__MX__isNorm(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isNorm(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isOne" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isOne"
// cWrapperName: "casadi__MX__isOne"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isOne(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isOne()"
// params: []
extern "C"
    int casadi__MX__isOne(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isOne(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isOperation" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isOperation"
// cWrapperName: "casadi__MX__isOperation"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isOperation(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->isOperation(x0_)"
// params: [CInt]
extern "C"
    int casadi__MX__isOperation(std::string ** err_msg, casadi::MX* obj, int x0);
int casadi__MX__isOperation(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "isRegular" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isRegular"
// cWrapperName: "casadi__MX__isRegular"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isRegular(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isRegular()"
// params: []
extern "C"
    int casadi__MX__isRegular(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isRegular(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isScalar" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isScalar"
// cWrapperName: "casadi__MX__isScalar__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isScalar__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isScalar()"
// params: []
extern "C"
    int casadi__MX__isScalar__0(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isScalar__0(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isScalar" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isScalar"
// cWrapperName: "casadi__MX__isScalar__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isScalar__1(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->isScalar(x0_)"
// params: [CBool]
extern "C"
    int casadi__MX__isScalar__1(std::string ** err_msg, casadi::MX* obj, int x0);
int casadi__MX__isScalar__1(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

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


// ================== Normal method: "isSquare" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isSquare"
// cWrapperName: "casadi__MX__isSquare"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isSquare(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isSquare()"
// params: []
extern "C"
    int casadi__MX__isSquare(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isSquare(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isSymbolic" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isSymbolic"
// cWrapperName: "casadi__MX__isSymbolic"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isSymbolic(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isSymbolic()"
// params: []
extern "C"
    int casadi__MX__isSymbolic(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isSymbolic(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isSymbolicSparse" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isSymbolicSparse"
// cWrapperName: "casadi__MX__isSymbolicSparse"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isSymbolicSparse(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isSymbolicSparse()"
// params: []
extern "C"
    int casadi__MX__isSymbolicSparse(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isSymbolicSparse(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isTranspose" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isTranspose"
// cWrapperName: "casadi__MX__isTranspose"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isTranspose(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isTranspose()"
// params: []
extern "C"
    int casadi__MX__isTranspose(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isTranspose(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isTril" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isTril"
// cWrapperName: "casadi__MX__isTril"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isTril(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isTril()"
// params: []
extern "C"
    int casadi__MX__isTril(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isTril(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isTriu" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isTriu"
// cWrapperName: "casadi__MX__isTriu"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isTriu(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isTriu()"
// params: []
extern "C"
    int casadi__MX__isTriu(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isTriu(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isUnary" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isUnary"
// cWrapperName: "casadi__MX__isUnary"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isUnary(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isUnary()"
// params: []
extern "C"
    int casadi__MX__isUnary(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isUnary(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isVector" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isVector"
// cWrapperName: "casadi__MX__isVector"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isVector(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isVector()"
// params: []
extern "C"
    int casadi__MX__isVector(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isVector(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "isZero" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::isZero"
// cWrapperName: "casadi__MX__isZero"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__MX__isZero(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->isZero()"
// params: []
extern "C"
    int casadi__MX__isZero(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__isZero(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "lift" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::lift"
// cWrapperName: "casadi__MX__lift"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__lift(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->lift(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__lift(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
void casadi__MX__lift(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

    obj->lift(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "log" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::log"
// cWrapperName: "casadi__MX__log"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__log(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->log()"
// params: []
extern "C"
    casadi::MX* casadi__MX__log(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__log(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "log10" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::log10"
// cWrapperName: "casadi__MX__log10"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__log10(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->log10()"
// params: []
extern "C"
    casadi::MX* casadi__MX__log10(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__log10(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "logic_and" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::logic_and"
// cWrapperName: "casadi__MX__logic_and"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__logic_and(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->logic_and(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__logic_and(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__logic_and(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "logic_not" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::logic_not"
// cWrapperName: "casadi__MX__logic_not"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__logic_not(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->logic_not()"
// params: []
extern "C"
    casadi::MX* casadi__MX__logic_not(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__logic_not(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "logic_or" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::logic_or"
// cWrapperName: "casadi__MX__logic_or"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__logic_or(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->logic_or(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__logic_or(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__logic_or(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "mapping" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::mapping"
// cWrapperName: "casadi__MX__mapping"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix")
// cWrapperRetType: "casadi::IMatrix*"
// proto: "casadi::IMatrix* casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->mapping()"
// params: []
extern "C"
    casadi::IMatrix* casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj);
casadi::IMatrix* casadi__MX__mapping(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "mul" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::mul"
// cWrapperName: "casadi__MX__mul__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__mul__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->mul(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__mul__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__mul__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "mul" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::mul"
// cWrapperName: "casadi__MX__mul__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__mul__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__mul__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1);
casadi::MX* casadi__MX__mul__1(std::string ** err_msg, casadi::MX* obj, 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 = obj->mul(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul_full" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::mul_full"
// cWrapperName: "casadi__MX__mul_full__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__mul_full__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->mul_full(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__mul_full__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__mul_full__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "mul_full" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::mul_full"
// cWrapperName: "casadi__MX__mul_full__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__mul_full__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__mul_full__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1);
casadi::MX* casadi__MX__mul_full__1(std::string ** err_msg, casadi::MX* obj, 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 = obj->mul_full(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul_smart" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::mul_smart"
// cWrapperName: "casadi__MX__mul_smart"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__mul_smart(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__mul_smart(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1);
casadi::MX* casadi__MX__mul_smart(std::string ** err_msg, casadi::MX* obj, 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 = obj->mul_smart(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nan"
// cWrapperName: "casadi__MX__nan__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nan__0(std::string ** err_msg)"
// call: "casadi::MX::nan()"
// params: []
extern "C"
    casadi::MX* casadi__MX__nan__0(std::string ** err_msg);
casadi::MX* casadi__MX__nan__0(std::string ** err_msg){
    try {

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


// ================== Static method: "nan" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nan"
// cWrapperName: "casadi__MX__nan__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nan__1(std::string ** err_msg, int x0)"
// call: "casadi::MX::nan(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__nan__1(std::string ** err_msg, int x0);
casadi::MX* casadi__MX__nan__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "nan" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nan"
// cWrapperName: "casadi__MX__nan__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nan__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::MX::nan(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__nan__2(std::string ** err_msg, int x0, int x1);
casadi::MX* casadi__MX__nan__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Static method: "nan" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nan"
// cWrapperName: "casadi__MX__nan__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nan__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::MX::nan(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__nan__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::MX* casadi__MX__nan__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "numel" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::numel"
// cWrapperName: "casadi__MX__numel"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__numel(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->numel()"
// params: []
extern "C"
    int casadi__MX__numel(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__numel(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "nz_indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed"
// cWrapperName: "casadi__MX__nz_indexed__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nz_indexed__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__nz_indexed__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0);
casadi::MX* casadi__MX__nz_indexed__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

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


// ================== Normal method: "nz_indexed" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed"
// cWrapperName: "casadi__MX__nz_indexed__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nz_indexed__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0)"
// call: "obj->nz_indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__nz_indexed__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0);
casadi::MX* casadi__MX__nz_indexed__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

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


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed_assignment"
// cWrapperName: "casadi__MX__nz_indexed_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__nz_indexed_assignment__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__nz_indexed_assignment__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1);
void casadi__MX__nz_indexed_assignment__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed_assignment"
// cWrapperName: "casadi__MX__nz_indexed_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__nz_indexed_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__nz_indexed_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1);
void casadi__MX__nz_indexed_assignment__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed_one_based"
// cWrapperName: "casadi__MX__nz_indexed_one_based"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nz_indexed_one_based(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__nz_indexed_one_based(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__nz_indexed_one_based(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__MX__nz_indexed_one_based_assignment"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__nz_indexed_one_based_assignment(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__nz_indexed_one_based_assignment(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1);
void casadi__MX__nz_indexed_one_based_assignment(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed_zero_based"
// cWrapperName: "casadi__MX__nz_indexed_zero_based"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__nz_indexed_zero_based(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__nz_indexed_zero_based(std::string ** err_msg, casadi::MX* obj, int x0);
casadi::MX* casadi__MX__nz_indexed_zero_based(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__MX__nz_indexed_zero_based_assignment"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__nz_indexed_zero_based_assignment(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__nz_indexed_zero_based_assignment(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1);
void casadi__MX__nz_indexed_zero_based_assignment(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::ones"
// cWrapperName: "casadi__MX__ones__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__ones__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::MX::ones(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__ones__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::MX* casadi__MX__ones__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Static method: "ones" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::ones"
// cWrapperName: "casadi__MX__ones__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__ones__1(std::string ** err_msg)"
// call: "casadi::MX::ones()"
// params: []
extern "C"
    casadi::MX* casadi__MX__ones__1(std::string ** err_msg);
casadi::MX* casadi__MX__ones__1(std::string ** err_msg){
    try {

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


// ================== Static method: "ones" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::ones"
// cWrapperName: "casadi__MX__ones__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__ones__2(std::string ** err_msg, int x0)"
// call: "casadi::MX::ones(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__ones__2(std::string ** err_msg, int x0);
casadi::MX* casadi__MX__ones__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "ones" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::ones"
// cWrapperName: "casadi__MX__ones__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__ones__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::MX::ones(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__ones__3(std::string ** err_msg, int x0, int x1);
casadi::MX* casadi__MX__ones__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "outer_prod" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::outer_prod"
// cWrapperName: "casadi__MX__outer_prod"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__outer_prod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->outer_prod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__outer_prod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__outer_prod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Normal method: "printme" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::printme"
// cWrapperName: "casadi__MX__printme"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)"
// call: "obj->printme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0);
casadi::MX* casadi__MX__printme(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);

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


// ================== Static method: "repmat" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::repmat"
// cWrapperName: "casadi__MX__repmat__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__repmat__0(std::string ** err_msg, casadi::MX* x0, int x1)"
// call: "casadi::MX::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt]
extern "C"
    casadi::MX* casadi__MX__repmat__0(std::string ** err_msg, casadi::MX* x0, int x1);
casadi::MX* casadi__MX__repmat__0(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);

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


// ================== Static method: "repmat" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::repmat"
// cWrapperName: "casadi__MX__repmat__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__repmat__1(std::string ** err_msg, casadi::MX* x0, int x1, int x2)"
// call: "casadi::MX::repmat(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__repmat__1(std::string ** err_msg, casadi::MX* x0, int x1, int x2);
casadi::MX* casadi__MX__repmat__1(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::MX::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;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::repmat"
// cWrapperName: "casadi__MX__repmat__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__repmat__2(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1)"
// call: "casadi::MX::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__repmat__2(std::string ** err_msg, casadi::MX* x0, casadi::Sparsity* x1);
casadi::MX* casadi__MX__repmat__2(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::MX::repmat(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setEqualityCheckingDepth"
// cWrapperName: "casadi__MX__setEqualityCheckingDepth__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg)"
// call: "casadi::MX::setEqualityCheckingDepth()"
// params: []
extern "C"
    void casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg);
void casadi__MX__setEqualityCheckingDepth__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setEqualityCheckingDepth"
// cWrapperName: "casadi__MX__setEqualityCheckingDepth__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
// call: "casadi::MX::setEqualityCheckingDepth(x0_)"
// params: [CInt]
extern "C"
    void casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
void casadi__MX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setMaxNumCallsInPrint"
// cWrapperName: "casadi__MX__setMaxNumCallsInPrint__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setMaxNumCallsInPrint__0(std::string ** err_msg)"
// call: "casadi::MX::setMaxNumCallsInPrint()"
// params: []
extern "C"
    void casadi__MX__setMaxNumCallsInPrint__0(std::string ** err_msg);
void casadi__MX__setMaxNumCallsInPrint__0(std::string ** err_msg){
    try {

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


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setMaxNumCallsInPrint"
// cWrapperName: "casadi__MX__setMaxNumCallsInPrint__1"
// protoArgs: "(std::string ** err_msg, long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0)"
// call: "casadi::MX::setMaxNumCallsInPrint(x0_)"
// params: [CLong]
extern "C"
    void casadi__MX__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0);
void casadi__MX__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0){
    try {
        long x0_ = Marshaling<long,long>::marshal(x0);

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


// ================== Normal method: "setNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setNZ"
// cWrapperName: "casadi__MX__setNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__setNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1);
void casadi__MX__setNZ__0(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::MX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setNZ"
// cWrapperName: "casadi__MX__setNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__setNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1);
void casadi__MX__setNZ__1(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::MX* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setNZ"
// cWrapperName: "casadi__MX__setNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setNZ__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__setNZ__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::MX* x1);
void casadi__MX__setNZ__2(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::MX* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setNZ"
// cWrapperName: "casadi__MX__setNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setNZ__3(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    void casadi__MX__setNZ__3(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1);
void casadi__MX__setNZ__3(std::string ** err_msg, casadi::MX* obj, int x0, casadi::MX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSparse" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSparse"
// cWrapperName: "casadi__MX__setSparse__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__setSparse__0(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__setSparse__0(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0);
casadi::MX* casadi__MX__setSparse__0(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

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


// ================== Normal method: "setSparse" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSparse"
// cWrapperName: "casadi__MX__setSparse__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__setSparse__1(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
extern "C"
    casadi::MX* casadi__MX__setSparse__1(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1);
casadi::MX* casadi__MX__setSparse__1(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

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


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    void casadi__MX__setSub__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1, int x2);
void casadi__MX__setSub__0(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Sparsity* x1, int x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__MX__setSub__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__MX__setSub__1(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Slice* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Slice* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__MX__setSub__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Slice* x1, casadi::Slice* x2);
void casadi__MX__setSub__2(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::Slice* x1, casadi::Slice* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__MX__setSub__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2);
void casadi__MX__setSub__3(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, casadi::IMatrix* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__4"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__MX__setSub__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::IMatrix* x2);
void casadi__MX__setSub__4(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::IMatrix* 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);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__5"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    void casadi__MX__setSub__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, int x2);
void casadi__MX__setSub__5(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, int x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__6"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__MX__setSub__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, std::vector< int >* x2);
void casadi__MX__setSub__6(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, casadi::IMatrix* x1, std::vector< int >* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__7"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__7(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt)),UserType (Namespace ["casadi"]) (Name "Slice")]
extern "C"
    void casadi__MX__setSub__7(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::Slice* x2);
void casadi__MX__setSub__7(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, casadi::Slice* 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);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__8"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__8(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__MX__setSub__8(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, std::vector< int >* x2);
void casadi__MX__setSub__8(std::string ** err_msg, casadi::MX* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__9"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__9(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,Ref (Const (StdVec CInt))]
extern "C"
    void casadi__MX__setSub__9(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, std::vector< int >* x2);
void casadi__MX__setSub__9(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, std::vector< int >* x2){
    try {
        casadi::MX x0_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__10"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__10(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),Ref (Const (StdVec CInt)),CInt]
extern "C"
    void casadi__MX__setSub__10(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, int x2);
void casadi__MX__setSub__10(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, std::vector< int >* x1, 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);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setSub"
// cWrapperName: "casadi__MX__setSub__11"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setSub__11(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX"))),CInt,CInt]
extern "C"
    void casadi__MX__setSub__11(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0, int x1, int x2);
void casadi__MX__setSub__11(std::string ** err_msg, casadi::MX* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setTemp" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::setTemp"
// cWrapperName: "casadi__MX__setTemp"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->setTemp(x0_)"
// params: [CInt]
extern "C"
    void casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0);
void casadi__MX__setTemp(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setTemp(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sign" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sign"
// cWrapperName: "casadi__MX__sign"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sign(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sign()"
// params: []
extern "C"
    casadi::MX* casadi__MX__sign(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__sign(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sin" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sin"
// cWrapperName: "casadi__MX__sin"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sin(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sin()"
// params: []
extern "C"
    casadi::MX* casadi__MX__sin(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__sin(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sinh" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sinh"
// cWrapperName: "casadi__MX__sinh"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sinh(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sinh()"
// params: []
extern "C"
    casadi::MX* casadi__MX__sinh(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__sinh(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "size" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::size"
// cWrapperName: "casadi__MX__size__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__size__0(std::string ** err_msg, casadi::MX* obj, int x0)"
// call: "obj->size(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    int casadi__MX__size__0(std::string ** err_msg, casadi::MX* obj, int x0);
int casadi__MX__size__0(std::string ** err_msg, casadi::MX* obj, int x0){
    try {
        casadi::SparsityType x0_ = Marshaling<casadi::SparsityType,int>::marshal(x0);

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


// ================== Normal method: "size" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::size"
// cWrapperName: "casadi__MX__size__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__size__1(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->size()"
// params: []
extern "C"
    int casadi__MX__size__1(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__size__1(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "size1" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::size1"
// cWrapperName: "casadi__MX__size1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__size1(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->size1()"
// params: []
extern "C"
    int casadi__MX__size1(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__size1(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "size2" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::size2"
// cWrapperName: "casadi__MX__size2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__size2(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->size2()"
// params: []
extern "C"
    int casadi__MX__size2(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__size2(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sizeD" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sizeD"
// cWrapperName: "casadi__MX__sizeD"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__sizeD(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sizeD()"
// params: []
extern "C"
    int casadi__MX__sizeD(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__sizeD(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sizeL" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sizeL"
// cWrapperName: "casadi__MX__sizeL"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__sizeL(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sizeL()"
// params: []
extern "C"
    int casadi__MX__sizeL(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__sizeL(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sizeU" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sizeU"
// cWrapperName: "casadi__MX__sizeU"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MX__sizeU(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sizeU()"
// params: []
extern "C"
    int casadi__MX__sizeU(std::string ** err_msg, casadi::MX* obj);
int casadi__MX__sizeU(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Static method: "sparse" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparse"
// cWrapperName: "casadi__MX__sparse__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sparse__0(std::string ** err_msg)"
// call: "casadi::MX::sparse()"
// params: []
extern "C"
    casadi::MX* casadi__MX__sparse__0(std::string ** err_msg);
casadi::MX* casadi__MX__sparse__0(std::string ** err_msg){
    try {

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


// ================== Static method: "sparse" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparse"
// cWrapperName: "casadi__MX__sparse__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sparse__1(std::string ** err_msg, int x0)"
// call: "casadi::MX::sparse(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__sparse__1(std::string ** err_msg, int x0);
casadi::MX* casadi__MX__sparse__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

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


// ================== Static method: "sparse" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparse"
// cWrapperName: "casadi__MX__sparse__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sparse__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::MX::sparse(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__sparse__2(std::string ** err_msg, int x0, int x1);
casadi::MX* casadi__MX__sparse__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

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


// ================== Normal method: "sparsity" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparsity"
// cWrapperName: "casadi__MX__sparsity__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__MX__sparsity__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__MX__sparsity__0(std::string ** err_msg, casadi::MX* obj);
casadi::Sparsity* casadi__MX__sparsity__0(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sparsity" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparsity"
// cWrapperName: "casadi__MX__sparsity__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__MX__sparsity__1(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__MX__sparsity__1(std::string ** err_msg, casadi::MX* obj);
casadi::Sparsity* casadi__MX__sparsity__1(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparsityRef"
// cWrapperName: "casadi__MX__sparsityRef__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__MX__sparsityRef__0(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__MX__sparsityRef__0(std::string ** err_msg, casadi::MX* obj);
casadi::Sparsity* casadi__MX__sparsityRef__0(std::string ** err_msg, casadi::MX* obj){
    try {

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


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sparsityRef"
// cWrapperName: "casadi__MX__sparsityRef__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__MX__sparsityRef__1(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__MX__sparsityRef__1(std::string ** err_msg, casadi::MX* obj);
casadi::Sparsity* casadi__MX__sparsityRef__1(std::string ** err_msg, casadi::MX* obj){
    try {

        casadi::Sparsity ret = obj->sparsityRef();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sqrt" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sqrt"
// cWrapperName: "casadi__MX__sqrt"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sqrt(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->sqrt()"
// params: []
extern "C"
    casadi::MX* casadi__MX__sqrt(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__sqrt(std::string ** err_msg, casadi::MX* obj){
    try {

        casadi::MX ret = obj->sqrt();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__0"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__sub__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::IMatrix* x1);
casadi::MX* casadi__MX__sub__0(std::string ** err_msg, casadi::MX* obj, int x0, casadi::IMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__1"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__sub__1(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::MX* casadi__MX__sub__1(std::string ** err_msg, casadi::MX* obj, 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::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__2"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__2(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__sub__2(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::MX* casadi__MX__sub__2(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__3"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__3(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__sub__3(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::MX* casadi__MX__sub__3(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__4"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__4(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__sub__4(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::MX* casadi__MX__sub__4(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__5"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__5(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    casadi::MX* casadi__MX__sub__5(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, int x1);
casadi::MX* casadi__MX__sub__5(std::string ** err_msg, casadi::MX* obj, casadi::Slice* x0, int x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__6"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__6(std::string ** err_msg, casadi::MX* obj, int x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::MX* casadi__MX__sub__6(std::string ** err_msg, casadi::MX* obj, int x0, casadi::Slice* x1);
casadi::MX* casadi__MX__sub__6(std::string ** err_msg, casadi::MX* obj, int x0, casadi::Slice* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__7"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__7(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::MX* casadi__MX__sub__7(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::IMatrix* x1);
casadi::MX* casadi__MX__sub__7(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, casadi::IMatrix* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__8"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__8(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::MX* casadi__MX__sub__8(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, std::vector< int >* x1);
casadi::MX* casadi__MX__sub__8(std::string ** err_msg, casadi::MX* obj, 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);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__9"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__9(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    casadi::MX* casadi__MX__sub__9(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, int x1);
casadi::MX* casadi__MX__sub__9(std::string ** err_msg, casadi::MX* obj, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__10"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__10(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0)"
// call: "obj->sub(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__sub__10(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0);
casadi::MX* casadi__MX__sub__10(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::MX ret = obj->sub(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__11"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__11(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::MX* casadi__MX__sub__11(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1);
casadi::MX* casadi__MX__sub__11(std::string ** err_msg, casadi::MX* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__12"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__12(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::MX* casadi__MX__sub__12(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1);
casadi::MX* casadi__MX__sub__12(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__13"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__13(std::string ** err_msg, casadi::MX* obj, int x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (StdVec CInt))]
extern "C"
    casadi::MX* casadi__MX__sub__13(std::string ** err_msg, casadi::MX* obj, int x0, std::vector< int >* x1);
casadi::MX* casadi__MX__sub__13(std::string ** err_msg, casadi::MX* obj, int x0, std::vector< int >* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__14"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__14(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),CInt]
extern "C"
    casadi::MX* casadi__MX__sub__14(std::string ** err_msg, casadi::MX* obj, std::vector< int >* x0, int x1);
casadi::MX* casadi__MX__sub__14(std::string ** err_msg, casadi::MX* obj, 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);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sub"
// cWrapperName: "casadi__MX__sub__15"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sub__15(std::string ** err_msg, casadi::MX* obj, int x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__sub__15(std::string ** err_msg, casadi::MX* obj, int x0, int x1);
casadi::MX* casadi__MX__sub__15(std::string ** err_msg, casadi::MX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// call: "casadi::MX::sym(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::MX* >* >* casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< casadi::MX* >* >* casadi__MX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_, x4_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__1"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// cWrapperRetType: "std::vector< std::vector< casadi::MX* >* >*"
// proto: "std::vector< std::vector< casadi::MX* >* >* casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// call: "casadi::MX::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::MX* >* >* casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< casadi::MX* >* >* casadi__MX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< std::vector< casadi::MX > > ret = casadi::MX::sym(x0_, x1_, x2_, x3_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__2"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// call: "casadi::MX::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CInt,CInt]
extern "C"
    std::vector< casadi::MX* >* casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
std::vector< casadi::MX* >* casadi__MX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< casadi::MX > ret = casadi::MX::sym(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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__3"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// call: "casadi::MX::sym(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    std::vector< casadi::MX* >* casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
std::vector< casadi::MX* >* casadi__MX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< casadi::MX > ret = casadi::MX::sym(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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__4"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// call: "casadi::MX::sym(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
casadi::MX* casadi__MX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::MX ret = casadi::MX::sym(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__5"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sym__5(std::string ** err_msg, std::string* x0)"
// call: "casadi::MX::sym(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MX__sym__5(std::string ** err_msg, std::string* x0);
casadi::MX* casadi__MX__sym__5(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::MX ret = casadi::MX::sym(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__6"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sym__6(std::string ** err_msg, std::string* x0, int x1)"
// call: "casadi::MX::sym(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::MX* casadi__MX__sym__6(std::string ** err_msg, std::string* x0, int x1);
casadi::MX* casadi__MX__sym__6(std::string ** err_msg, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = casadi::MX::sym(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::sym"
// cWrapperName: "casadi__MX__sym__7"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1, int x2)"
// call: "casadi::MX::sym(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1, int x2);
casadi::MX* casadi__MX__sym__7(std::string ** err_msg, std::string* x0, int x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::MX ret = casadi::MX::sym(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tan" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::tan"
// cWrapperName: "casadi__MX__tan"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__tan(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->tan()"
// params: []
extern "C"
    casadi::MX* casadi__MX__tan(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__tan(std::string ** err_msg, casadi::MX* obj){
    try {

        casadi::MX ret = obj->tan();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tanh" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::tanh"
// cWrapperName: "casadi__MX__tanh"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__tanh(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->tanh()"
// params: []
extern "C"
    casadi::MX* casadi__MX__tanh(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__tanh(std::string ** err_msg, casadi::MX* obj){
    try {

        casadi::MX ret = obj->tanh();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "trans" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::trans"
// cWrapperName: "casadi__MX__trans"
// protoArgs: "(std::string ** err_msg, casadi::MX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__trans(std::string ** err_msg, casadi::MX* obj)"
// call: "obj->trans()"
// params: []
extern "C"
    casadi::MX* casadi__MX__trans(std::string ** err_msg, casadi::MX* obj);
casadi::MX* casadi__MX__trans(std::string ** err_msg, casadi::MX* obj){
    try {

        casadi::MX ret = obj->trans();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "unary" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::unary"
// cWrapperName: "casadi__MX__unary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1)"
// call: "casadi::MX::unary(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))]
extern "C"
    casadi::MX* casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1);
casadi::MX* casadi__MX__unary(std::string ** err_msg, int x0, casadi::MX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::MX x1_ = Marshaling<casadi::MX,casadi::MX*>::marshal(x1);

        casadi::MX ret = casadi::MX::unary(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::zeros"
// cWrapperName: "casadi__MX__zeros__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__zeros__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::MX::zeros(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::MX* casadi__MX__zeros__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::MX* casadi__MX__zeros__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::MX ret = casadi::MX::zeros(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::zeros"
// cWrapperName: "casadi__MX__zeros__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__zeros__1(std::string ** err_msg)"
// call: "casadi::MX::zeros()"
// params: []
extern "C"
    casadi::MX* casadi__MX__zeros__1(std::string ** err_msg);
casadi::MX* casadi__MX__zeros__1(std::string ** err_msg){
    try {

        casadi::MX ret = casadi::MX::zeros();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::zeros"
// cWrapperName: "casadi__MX__zeros__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__zeros__2(std::string ** err_msg, int x0)"
// call: "casadi::MX::zeros(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MX__zeros__2(std::string ** err_msg, int x0);
casadi::MX* casadi__MX__zeros__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::MX ret = casadi::MX::zeros(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::MX"
// cppName: "casadi::MX::zeros"
// cWrapperName: "casadi__MX__zeros__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MX__zeros__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::MX::zeros(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MX__zeros__3(std::string ** err_msg, int x0, int x1);
casadi::MX* casadi__MX__zeros__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = casadi::MX::zeros(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "MXFunction")===============
// classType: UserType (Namespace ["casadi"]) (Name "MXFunction")
extern "C"
    void delete_casadi__MXFunction(casadi::MXFunction* obj);
void delete_casadi__MXFunction(casadi::MXFunction* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction"
// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
// cWrapperRetType: "casadi::MXFunction*"
// proto: "casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1)"
// call: "casadi::MXFunction(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX"))))]
extern "C"
    casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::MX* >* x0, std::vector< casadi::MX* >* x1);
casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__0(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::MXFunction ret = casadi::MXFunction(x0_, x1_);
        return WrapReturn< casadi::MXFunction*, casadi::MXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction"
// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
// cWrapperRetType: "casadi::MXFunction*"
// proto: "casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0)"
// call: "casadi::MXFunction(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0);
casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);

        casadi::MXFunction ret = casadi::MXFunction(x0_);
        return WrapReturn< casadi::MXFunction*, casadi::MXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction"
// cWrapperName: "casadi__MXFunction__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MXFunction")
// cWrapperRetType: "casadi::MXFunction*"
// proto: "casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__2(std::string ** err_msg)"
// call: "casadi::MXFunction()"
// params: []
extern "C"
    casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__2(std::string ** err_msg);
casadi::MXFunction* casadi__MXFunction__CONSTRUCTOR__2(std::string ** err_msg){
    try {

        casadi::MXFunction ret = casadi::MXFunction();
        return WrapReturn< casadi::MXFunction*, casadi::MXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "countNodes" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::countNodes"
// cWrapperName: "casadi__MXFunction__countNodes"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MXFunction__countNodes(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->countNodes()"
// params: []
extern "C"
    int casadi__MXFunction__countNodes(std::string ** err_msg, casadi::MXFunction* obj);
int casadi__MXFunction__countNodes(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        int ret = obj->countNodes();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "expand" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::expand"
// cWrapperName: "casadi__MXFunction__expand__0"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
// cWrapperRetType: "casadi::SXFunction*"
// proto: "casadi::SXFunction* casadi__MXFunction__expand__0(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->expand()"
// params: []
extern "C"
    casadi::SXFunction* casadi__MXFunction__expand__0(std::string ** err_msg, casadi::MXFunction* obj);
casadi::SXFunction* casadi__MXFunction__expand__0(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        casadi::SXFunction ret = obj->expand();
        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "expand" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::expand"
// cWrapperName: "casadi__MXFunction__expand__1"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
// cWrapperRetType: "casadi::SXFunction*"
// proto: "casadi::SXFunction* casadi__MXFunction__expand__1(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0)"
// call: "obj->expand(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
extern "C"
    casadi::SXFunction* casadi__MXFunction__expand__1(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0);
casadi::SXFunction* casadi__MXFunction__expand__1(std::string ** err_msg, casadi::MXFunction* obj, std::vector< casadi::SX* >* x0){
    try {
        std::vector< casadi::SX > x0_ = Marshaling<std::vector< casadi::SX >,std::vector< casadi::SX* >*>::marshal(x0);

        casadi::SXFunction ret = obj->expand(x0_);
        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "generateLiftingFunctions" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::generateLiftingFunctions"
// cWrapperName: "casadi__MXFunction__generateLiftingFunctions"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__MXFunction__generateLiftingFunctions(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1)"
// call: "obj->generateLiftingFunctions(x0_, x1_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "MXFunction")),Ref (UserType (Namespace ["casadi"]) (Name "MXFunction"))]
extern "C"
    void casadi__MXFunction__generateLiftingFunctions(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1);
void casadi__MXFunction__generateLiftingFunctions(std::string ** err_msg, casadi::MXFunction* obj, casadi::MXFunction* x0, casadi::MXFunction* x1){
    try {
        casadi::MXFunction x0_ = Marshaling<casadi::MXFunction,casadi::MXFunction*>::marshal(x0);
        casadi::MXFunction x1_ = Marshaling<casadi::MXFunction,casadi::MXFunction*>::marshal(x1);

    obj->generateLiftingFunctions(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getAlgorithmSize" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::getAlgorithmSize"
// cWrapperName: "casadi__MXFunction__getAlgorithmSize"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MXFunction__getAlgorithmSize(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->getAlgorithmSize()"
// params: []
extern "C"
    int casadi__MXFunction__getAlgorithmSize(std::string ** err_msg, casadi::MXFunction* obj);
int casadi__MXFunction__getAlgorithmSize(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        int ret = obj->getAlgorithmSize();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getFree" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::getFree"
// cWrapperName: "casadi__MXFunction__getFree"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__MXFunction__getFree(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->getFree()"
// params: []
extern "C"
    std::vector< casadi::MX* >* casadi__MXFunction__getFree(std::string ** err_msg, casadi::MXFunction* obj);
std::vector< casadi::MX* >* casadi__MXFunction__getFree(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        std::vector< casadi::MX > ret = obj->getFree();
        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;
    }
}


// ================== Normal method: "getWorkSize" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::getWorkSize"
// cWrapperName: "casadi__MXFunction__getWorkSize"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__MXFunction__getWorkSize(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->getWorkSize()"
// params: []
extern "C"
    int casadi__MXFunction__getWorkSize(std::string ** err_msg, casadi::MXFunction* obj);
int casadi__MXFunction__getWorkSize(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        int ret = obj->getWorkSize();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__0"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__grad__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1);
casadi::MX* casadi__MXFunction__grad__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::MX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__1"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__grad__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1);
casadi::MX* casadi__MXFunction__grad__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::MX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__2"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// call: "obj->grad(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__grad__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
casadi::MX* casadi__MXFunction__grad__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::MX ret = obj->grad(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__3"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
// call: "obj->grad(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::MX* casadi__MXFunction__grad__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1);
casadi::MX* casadi__MXFunction__grad__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__4"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__4(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->grad()"
// params: []
extern "C"
    casadi::MX* casadi__MXFunction__grad__4(std::string ** err_msg, casadi::MXFunction* obj);
casadi::MX* casadi__MXFunction__grad__4(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        casadi::MX ret = obj->grad();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__5"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__5(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// call: "obj->grad(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MXFunction__grad__5(std::string ** err_msg, casadi::MXFunction* obj, int x0);
casadi::MX* casadi__MXFunction__grad__5(std::string ** err_msg, casadi::MXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::MX ret = obj->grad(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::grad"
// cWrapperName: "casadi__MXFunction__grad__6"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__grad__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
// call: "obj->grad(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MXFunction__grad__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1);
casadi::MX* casadi__MXFunction__grad__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "inputExpr" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::inputExpr"
// cWrapperName: "casadi__MXFunction__inputExpr__0"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__MXFunction__inputExpr__0(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->inputExpr()"
// params: []
extern "C"
    std::vector< casadi::MX* >* casadi__MXFunction__inputExpr__0(std::string ** err_msg, casadi::MXFunction* obj);
std::vector< casadi::MX* >* casadi__MXFunction__inputExpr__0(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        std::vector< casadi::MX > ret = obj->inputExpr();
        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;
    }
}


// ================== Normal method: "inputExpr" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::inputExpr"
// cWrapperName: "casadi__MXFunction__inputExpr__1"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__inputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// call: "obj->inputExpr(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__inputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
casadi::MX* casadi__MXFunction__inputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::MX ret = obj->inputExpr(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "inputExpr" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::inputExpr"
// cWrapperName: "casadi__MXFunction__inputExpr__2"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__inputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// call: "obj->inputExpr(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MXFunction__inputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0);
casadi::MX* casadi__MXFunction__inputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::MX ret = obj->inputExpr(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__0"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__jac__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1);
casadi::MX* casadi__MXFunction__jac__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::MX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__1"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2);
casadi::MX* casadi__MXFunction__jac__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::MX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__2"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3);
casadi::MX* casadi__MXFunction__jac__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__3"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__3(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__jac__3(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1);
casadi::MX* casadi__MXFunction__jac__3(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::MX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__4"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__4(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [CInt,Ref (Const StdString),CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__4(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2);
casadi::MX* casadi__MXFunction__jac__4(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::MX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__5"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__5(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [CInt,Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__5(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3);
casadi::MX* casadi__MXFunction__jac__5(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__6"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__6(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// call: "obj->jac(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__jac__6(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
casadi::MX* casadi__MXFunction__jac__6(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::MX ret = obj->jac(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__7"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__7(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
// call: "obj->jac(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::MX* casadi__MXFunction__jac__7(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1);
casadi::MX* casadi__MXFunction__jac__7(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__8"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__8(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CInt,CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__8(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2);
casadi::MX* casadi__MXFunction__jac__8(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::MX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__9"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__9(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CBool,CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__9(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3);
casadi::MX* casadi__MXFunction__jac__9(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__10"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__10(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->jac()"
// params: []
extern "C"
    casadi::MX* casadi__MXFunction__jac__10(std::string ** err_msg, casadi::MXFunction* obj);
casadi::MX* casadi__MXFunction__jac__10(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        casadi::MX ret = obj->jac();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__11"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__11(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// call: "obj->jac(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MXFunction__jac__11(std::string ** err_msg, casadi::MXFunction* obj, int x0);
casadi::MX* casadi__MXFunction__jac__11(std::string ** err_msg, casadi::MXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::MX ret = obj->jac(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__12"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__12(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
// call: "obj->jac(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MXFunction__jac__12(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1);
casadi::MX* casadi__MXFunction__jac__12(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__13"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__13(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [CInt,CInt,CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__13(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2);
casadi::MX* casadi__MXFunction__jac__13(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::MX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::jac"
// cWrapperName: "casadi__MXFunction__jac__14"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__jac__14(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,CBool,CBool]
extern "C"
    casadi::MX* casadi__MXFunction__jac__14(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3);
casadi::MX* casadi__MXFunction__jac__14(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::MX ret = obj->jac(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "outputExpr" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::outputExpr"
// cWrapperName: "casadi__MXFunction__outputExpr__0"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "MX")))
// cWrapperRetType: "std::vector< casadi::MX* >*"
// proto: "std::vector< casadi::MX* >* casadi__MXFunction__outputExpr__0(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->outputExpr()"
// params: []
extern "C"
    std::vector< casadi::MX* >* casadi__MXFunction__outputExpr__0(std::string ** err_msg, casadi::MXFunction* obj);
std::vector< casadi::MX* >* casadi__MXFunction__outputExpr__0(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        std::vector< casadi::MX > ret = obj->outputExpr();
        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;
    }
}


// ================== Normal method: "outputExpr" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::outputExpr"
// cWrapperName: "casadi__MXFunction__outputExpr__1"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__outputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// call: "obj->outputExpr(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__outputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
casadi::MX* casadi__MXFunction__outputExpr__1(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::MX ret = obj->outputExpr(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "outputExpr" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::outputExpr"
// cWrapperName: "casadi__MXFunction__outputExpr__2"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "MX"))
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__outputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// call: "obj->outputExpr(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MXFunction__outputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0);
casadi::MX* casadi__MXFunction__outputExpr__2(std::string ** err_msg, casadi::MXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::MX ret = obj->outputExpr(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__0"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__tang__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1);
casadi::MX* casadi__MXFunction__tang__0(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::MX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__1"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__tang__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1);
casadi::MX* casadi__MXFunction__tang__1(std::string ** err_msg, casadi::MXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::MX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__2"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0)"
// call: "obj->tang(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::MX* casadi__MXFunction__tang__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0);
casadi::MX* casadi__MXFunction__tang__2(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::MX ret = obj->tang(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__3"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1)"
// call: "obj->tang(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::MX* casadi__MXFunction__tang__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1);
casadi::MX* casadi__MXFunction__tang__3(std::string ** err_msg, casadi::MXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__4"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__4(std::string ** err_msg, casadi::MXFunction* obj)"
// call: "obj->tang()"
// params: []
extern "C"
    casadi::MX* casadi__MXFunction__tang__4(std::string ** err_msg, casadi::MXFunction* obj);
casadi::MX* casadi__MXFunction__tang__4(std::string ** err_msg, casadi::MXFunction* obj){
    try {

        casadi::MX ret = obj->tang();
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__5"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__5(std::string ** err_msg, casadi::MXFunction* obj, int x0)"
// call: "obj->tang(x0_)"
// params: [CInt]
extern "C"
    casadi::MX* casadi__MXFunction__tang__5(std::string ** err_msg, casadi::MXFunction* obj, int x0);
casadi::MX* casadi__MXFunction__tang__5(std::string ** err_msg, casadi::MXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::MX ret = obj->tang(x0_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::MXFunction"
// cppName: "casadi::MXFunction::tang"
// cWrapperName: "casadi__MXFunction__tang__6"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "MX")
// cWrapperRetType: "casadi::MX*"
// proto: "casadi::MX* casadi__MXFunction__tang__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1)"
// call: "obj->tang(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::MX* casadi__MXFunction__tang__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1);
casadi::MX* casadi__MXFunction__tang__6(std::string ** err_msg, casadi::MXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::MX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "NLPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "NLPSolver")
extern "C"
    void delete_casadi__NLPSolver(casadi::NLPSolver* obj);
void delete_casadi__NLPSolver(casadi::NLPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver"
// cWrapperName: "casadi__NLPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "NLPSolver")
// cWrapperRetType: "casadi::NLPSolver*"
// proto: "casadi::NLPSolver* casadi__NLPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::NLPSolver()"
// params: []
extern "C"
    casadi::NLPSolver* casadi__NLPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::NLPSolver* casadi__NLPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::NLPSolver ret = casadi::NLPSolver();
        return WrapReturn< casadi::NLPSolver*, casadi::NLPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getReportConstraints" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::getReportConstraints"
// cWrapperName: "casadi__NLPSolver__getReportConstraints"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__NLPSolver__getReportConstraints(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->getReportConstraints()"
// params: []
extern "C"
    std::string* casadi__NLPSolver__getReportConstraints(std::string ** err_msg, casadi::NLPSolver* obj);
std::string* casadi__NLPSolver__getReportConstraints(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

        std::string ret = obj->getReportConstraints();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "gradF" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::gradF"
// cWrapperName: "casadi__NLPSolver__gradF"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__NLPSolver__gradF(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->gradF()"
// params: []
extern "C"
    casadi::Function* casadi__NLPSolver__gradF(std::string ** err_msg, casadi::NLPSolver* obj);
casadi::Function* casadi__NLPSolver__gradF(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

        casadi::Function ret = obj->gradF();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hessLag" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::hessLag"
// cWrapperName: "casadi__NLPSolver__hessLag"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__NLPSolver__hessLag(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->hessLag()"
// params: []
extern "C"
    casadi::Function* casadi__NLPSolver__hessLag(std::string ** err_msg, casadi::NLPSolver* obj);
casadi::Function* casadi__NLPSolver__hessLag(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

        casadi::Function ret = obj->hessLag();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jacG" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::jacG"
// cWrapperName: "casadi__NLPSolver__jacG"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__NLPSolver__jacG(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->jacG()"
// params: []
extern "C"
    casadi::Function* casadi__NLPSolver__jacG(std::string ** err_msg, casadi::NLPSolver* obj);
casadi::Function* casadi__NLPSolver__jacG(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

        casadi::Function ret = obj->jacG();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "joinFG" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::joinFG"
// cWrapperName: "casadi__NLPSolver__joinFG"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__NLPSolver__joinFG(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1)"
// call: "casadi::NLPSolver::joinFG(x0_, x1_)"
// params: [UserType (Namespace ["casadi"]) (Name "Function"),UserType (Namespace ["casadi"]) (Name "Function")]
extern "C"
    casadi::Function* casadi__NLPSolver__joinFG(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1);
casadi::Function* casadi__NLPSolver__joinFG(std::string ** err_msg, casadi::Function* x0, casadi::Function* x1){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);

        casadi::Function ret = casadi::NLPSolver::joinFG(x0_, x1_);
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nlp" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::nlp"
// cWrapperName: "casadi__NLPSolver__nlp"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__NLPSolver__nlp(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->nlp()"
// params: []
extern "C"
    casadi::Function* casadi__NLPSolver__nlp(std::string ** err_msg, casadi::NLPSolver* obj);
casadi::Function* casadi__NLPSolver__nlp(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

        casadi::Function ret = obj->nlp();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "reportConstraints" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::reportConstraints"
// cWrapperName: "casadi__NLPSolver__reportConstraints"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__NLPSolver__reportConstraints(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->reportConstraints()"
// params: []
extern "C"
    void casadi__NLPSolver__reportConstraints(std::string ** err_msg, casadi::NLPSolver* obj);
void casadi__NLPSolver__reportConstraints(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

    obj->reportConstraints();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setQPOptions" ===============
// class: "casadi::NLPSolver"
// cppName: "casadi::NLPSolver::setQPOptions"
// cWrapperName: "casadi__NLPSolver__setQPOptions"
// protoArgs: "(std::string ** err_msg, casadi::NLPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__NLPSolver__setQPOptions(std::string ** err_msg, casadi::NLPSolver* obj)"
// call: "obj->setQPOptions()"
// params: []
extern "C"
    void casadi__NLPSolver__setQPOptions(std::string ** err_msg, casadi::NLPSolver* obj);
void casadi__NLPSolver__setQPOptions(std::string ** err_msg, casadi::NLPSolver* obj){
    try {

    obj->setQPOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "Nullspace")===============
// classType: UserType (Namespace ["casadi"]) (Name "Nullspace")
extern "C"
    void delete_casadi__Nullspace(casadi::Nullspace* obj);
void delete_casadi__Nullspace(casadi::Nullspace* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Nullspace"
// cppName: "casadi::Nullspace"
// cWrapperName: "casadi__Nullspace__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Nullspace")
// cWrapperRetType: "casadi::Nullspace*"
// proto: "casadi::Nullspace* casadi__Nullspace__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::Nullspace()"
// params: []
extern "C"
    casadi::Nullspace* casadi__Nullspace__CONSTRUCTOR(std::string ** err_msg);
casadi::Nullspace* casadi__Nullspace__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::Nullspace ret = casadi::Nullspace();
        return WrapReturn< casadi::Nullspace*, casadi::Nullspace >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "OCPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "OCPSolver")
extern "C"
    void delete_casadi__OCPSolver(casadi::OCPSolver* obj);
void delete_casadi__OCPSolver(casadi::OCPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::OCPSolver"
// cppName: "casadi::OCPSolver"
// cWrapperName: "casadi__OCPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "OCPSolver")
// cWrapperRetType: "casadi::OCPSolver*"
// proto: "casadi::OCPSolver* casadi__OCPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::OCPSolver()"
// params: []
extern "C"
    casadi::OCPSolver* casadi__OCPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::OCPSolver* casadi__OCPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::OCPSolver ret = casadi::OCPSolver();
        return WrapReturn< casadi::OCPSolver*, casadi::OCPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getCfcn" ===============
// class: "casadi::OCPSolver"
// cppName: "casadi::OCPSolver::getCfcn"
// cWrapperName: "casadi__OCPSolver__getCfcn"
// protoArgs: "(std::string ** err_msg, casadi::OCPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__OCPSolver__getCfcn(std::string ** err_msg, casadi::OCPSolver* obj)"
// call: "obj->getCfcn()"
// params: []
extern "C"
    casadi::Function* casadi__OCPSolver__getCfcn(std::string ** err_msg, casadi::OCPSolver* obj);
casadi::Function* casadi__OCPSolver__getCfcn(std::string ** err_msg, casadi::OCPSolver* obj){
    try {

        casadi::Function ret = obj->getCfcn();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getFfcn" ===============
// class: "casadi::OCPSolver"
// cppName: "casadi::OCPSolver::getFfcn"
// cWrapperName: "casadi__OCPSolver__getFfcn"
// protoArgs: "(std::string ** err_msg, casadi::OCPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__OCPSolver__getFfcn(std::string ** err_msg, casadi::OCPSolver* obj)"
// call: "obj->getFfcn()"
// params: []
extern "C"
    casadi::Function* casadi__OCPSolver__getFfcn(std::string ** err_msg, casadi::OCPSolver* obj);
casadi::Function* casadi__OCPSolver__getFfcn(std::string ** err_msg, casadi::OCPSolver* obj){
    try {

        casadi::Function ret = obj->getFfcn();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getMfcn" ===============
// class: "casadi::OCPSolver"
// cppName: "casadi::OCPSolver::getMfcn"
// cWrapperName: "casadi__OCPSolver__getMfcn"
// protoArgs: "(std::string ** err_msg, casadi::OCPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__OCPSolver__getMfcn(std::string ** err_msg, casadi::OCPSolver* obj)"
// call: "obj->getMfcn()"
// params: []
extern "C"
    casadi::Function* casadi__OCPSolver__getMfcn(std::string ** err_msg, casadi::OCPSolver* obj);
casadi::Function* casadi__OCPSolver__getMfcn(std::string ** err_msg, casadi::OCPSolver* obj){
    try {

        casadi::Function ret = obj->getMfcn();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getRfcn" ===============
// class: "casadi::OCPSolver"
// cppName: "casadi::OCPSolver::getRfcn"
// cWrapperName: "casadi__OCPSolver__getRfcn"
// protoArgs: "(std::string ** err_msg, casadi::OCPSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Function")
// cWrapperRetType: "casadi::Function*"
// proto: "casadi::Function* casadi__OCPSolver__getRfcn(std::string ** err_msg, casadi::OCPSolver* obj)"
// call: "obj->getRfcn()"
// params: []
extern "C"
    casadi::Function* casadi__OCPSolver__getRfcn(std::string ** err_msg, casadi::OCPSolver* obj);
casadi::Function* casadi__OCPSolver__getRfcn(std::string ** err_msg, casadi::OCPSolver* obj){
    try {

        casadi::Function ret = obj->getRfcn();
        return WrapReturn< casadi::Function*, casadi::Function >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")===============
// classType: UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")
extern "C"
    void delete_casadi__OptionsFunctionality(casadi::OptionsFunctionality* obj);
void delete_casadi__OptionsFunctionality(casadi::OptionsFunctionality* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality"
// cWrapperName: "casadi__OptionsFunctionality__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")
// cWrapperRetType: "casadi::OptionsFunctionality*"
// proto: "casadi::OptionsFunctionality* casadi__OptionsFunctionality__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::OptionsFunctionality()"
// params: []
extern "C"
    casadi::OptionsFunctionality* casadi__OptionsFunctionality__CONSTRUCTOR(std::string ** err_msg);
casadi::OptionsFunctionality* casadi__OptionsFunctionality__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::OptionsFunctionality ret = casadi::OptionsFunctionality();
        return WrapReturn< casadi::OptionsFunctionality*, casadi::OptionsFunctionality >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "copyOptions" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::copyOptions"
// cWrapperName: "casadi__OptionsFunctionality__copyOptions__0"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__OptionsFunctionality__copyOptions__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0)"
// call: "obj->copyOptions(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "OptionsFunctionality")))]
extern "C"
    void casadi__OptionsFunctionality__copyOptions__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0);
void casadi__OptionsFunctionality__copyOptions__0(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0){
    try {
        casadi::OptionsFunctionality x0_ = Marshaling<casadi::OptionsFunctionality,casadi::OptionsFunctionality*>::marshal(x0);

    obj->copyOptions(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "copyOptions" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::copyOptions"
// cWrapperName: "casadi__OptionsFunctionality__copyOptions__1"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__OptionsFunctionality__copyOptions__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1)"
// call: "obj->copyOptions(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "OptionsFunctionality"))),CBool]
extern "C"
    void casadi__OptionsFunctionality__copyOptions__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1);
void casadi__OptionsFunctionality__copyOptions__1(std::string ** err_msg, casadi::OptionsFunctionality* obj, casadi::OptionsFunctionality* x0, int x1){
    try {
        casadi::OptionsFunctionality x0_ = Marshaling<casadi::OptionsFunctionality,casadi::OptionsFunctionality*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

    obj->copyOptions(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getOption" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOption"
// cWrapperName: "casadi__OptionsFunctionality__getOption"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__OptionsFunctionality__getOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOption(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::GenericType* casadi__OptionsFunctionality__getOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
casadi::GenericType* casadi__OptionsFunctionality__getOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::GenericType ret = obj->getOption(x0_);
        return WrapReturn< casadi::GenericType*, casadi::GenericType >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionAllowed" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionAllowed"
// cWrapperName: "casadi__OptionsFunctionality__getOptionAllowed"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "GenericType"))
// cWrapperRetType: "std::vector< casadi::GenericType* >*"
// proto: "std::vector< casadi::GenericType* >* casadi__OptionsFunctionality__getOptionAllowed(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionAllowed(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    std::vector< casadi::GenericType* >* casadi__OptionsFunctionality__getOptionAllowed(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
std::vector< casadi::GenericType* >* casadi__OptionsFunctionality__getOptionAllowed(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        std::vector< casadi::GenericType > ret = obj->getOptionAllowed(x0_);
        return WrapReturn< std::vector< casadi::GenericType* >*, std::vector< casadi::GenericType > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionAllowedIndex" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionAllowedIndex"
// cWrapperName: "casadi__OptionsFunctionality__getOptionAllowedIndex"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__OptionsFunctionality__getOptionAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionAllowedIndex(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__OptionsFunctionality__getOptionAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
int casadi__OptionsFunctionality__getOptionAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        int ret = obj->getOptionAllowedIndex(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionDefault" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionDefault"
// cWrapperName: "casadi__OptionsFunctionality__getOptionDefault"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "GenericType")
// cWrapperRetType: "casadi::GenericType*"
// proto: "casadi::GenericType* casadi__OptionsFunctionality__getOptionDefault(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionDefault(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::GenericType* casadi__OptionsFunctionality__getOptionDefault(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
casadi::GenericType* casadi__OptionsFunctionality__getOptionDefault(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::GenericType ret = obj->getOptionDefault(x0_);
        return WrapReturn< casadi::GenericType*, casadi::GenericType >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionDescription" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionDescription"
// cWrapperName: "casadi__OptionsFunctionality__getOptionDescription"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__OptionsFunctionality__getOptionDescription(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionDescription(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    std::string* casadi__OptionsFunctionality__getOptionDescription(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
std::string* casadi__OptionsFunctionality__getOptionDescription(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        std::string ret = obj->getOptionDescription(x0_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionEnumValue" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionEnumValue"
// cWrapperName: "casadi__OptionsFunctionality__getOptionEnumValue"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__OptionsFunctionality__getOptionEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionEnumValue(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__OptionsFunctionality__getOptionEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
int casadi__OptionsFunctionality__getOptionEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        int ret = obj->getOptionEnumValue(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionNames" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionNames"
// cWrapperName: "casadi__OptionsFunctionality__getOptionNames"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
// args: "()"
// rettype: StdVec StdString
// cWrapperRetType: "std::vector< std::string* >*"
// proto: "std::vector< std::string* >* casadi__OptionsFunctionality__getOptionNames(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
// call: "obj->getOptionNames()"
// params: []
extern "C"
    std::vector< std::string* >* casadi__OptionsFunctionality__getOptionNames(std::string ** err_msg, casadi::OptionsFunctionality* obj);
std::vector< std::string* >* casadi__OptionsFunctionality__getOptionNames(std::string ** err_msg, casadi::OptionsFunctionality* obj){
    try {

        std::vector< std::string > ret = obj->getOptionNames();
        return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionType" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionType"
// cWrapperName: "casadi__OptionsFunctionality__getOptionType"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CEnum (Namespace ["casadi"]) (Name "opt_type")
// cWrapperRetType: "int"
// proto: "int casadi__OptionsFunctionality__getOptionType(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionType(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__OptionsFunctionality__getOptionType(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
int casadi__OptionsFunctionality__getOptionType(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::opt_type ret = obj->getOptionType(x0_);
        return WrapReturn< int, casadi::opt_type >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOptionTypeName" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::getOptionTypeName"
// cWrapperName: "casadi__OptionsFunctionality__getOptionTypeName"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__OptionsFunctionality__getOptionTypeName(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionTypeName(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    std::string* casadi__OptionsFunctionality__getOptionTypeName(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
std::string* casadi__OptionsFunctionality__getOptionTypeName(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        std::string ret = obj->getOptionTypeName(x0_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hasOption" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::hasOption"
// cWrapperName: "casadi__OptionsFunctionality__hasOption"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__OptionsFunctionality__hasOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->hasOption(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__OptionsFunctionality__hasOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
int casadi__OptionsFunctionality__hasOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        bool ret = obj->hasOption(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hasSetOption" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::hasSetOption"
// cWrapperName: "casadi__OptionsFunctionality__hasSetOption"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__OptionsFunctionality__hasSetOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->hasSetOption(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__OptionsFunctionality__hasSetOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0);
int casadi__OptionsFunctionality__hasSetOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        bool ret = obj->hasSetOption(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "printOptions" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::printOptions"
// cWrapperName: "casadi__OptionsFunctionality__printOptions"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__OptionsFunctionality__printOptions(std::string ** err_msg, casadi::OptionsFunctionality* obj)"
// call: "obj->printOptions()"
// params: []
extern "C"
    void casadi__OptionsFunctionality__printOptions(std::string ** err_msg, casadi::OptionsFunctionality* obj);
void casadi__OptionsFunctionality__printOptions(std::string ** err_msg, casadi::OptionsFunctionality* obj){
    try {

    obj->printOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOption" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::setOption"
// cWrapperName: "casadi__OptionsFunctionality__setOption"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__OptionsFunctionality__setOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1)"
// call: "obj->setOption(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "GenericType")))]
extern "C"
    void casadi__OptionsFunctionality__setOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1);
void casadi__OptionsFunctionality__setOption(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, casadi::GenericType* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::GenericType x1_ = Marshaling<casadi::GenericType,casadi::GenericType*>::marshal(x1);

    obj->setOption(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOptionByAllowedIndex" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::setOptionByAllowedIndex"
// cWrapperName: "casadi__OptionsFunctionality__setOptionByAllowedIndex"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__OptionsFunctionality__setOptionByAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
// call: "obj->setOptionByAllowedIndex(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    void casadi__OptionsFunctionality__setOptionByAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1);
void casadi__OptionsFunctionality__setOptionByAllowedIndex(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOptionByAllowedIndex(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOptionByEnumValue" ===============
// class: "casadi::OptionsFunctionality"
// cppName: "casadi::OptionsFunctionality::setOptionByEnumValue"
// cWrapperName: "casadi__OptionsFunctionality__setOptionByEnumValue"
// protoArgs: "(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__OptionsFunctionality__setOptionByEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1)"
// call: "obj->setOptionByEnumValue(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    void casadi__OptionsFunctionality__setOptionByEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1);
void casadi__OptionsFunctionality__setOptionByEnumValue(std::string ** err_msg, casadi::OptionsFunctionality* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOptionByEnumValue(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "Parallelizer")===============
// classType: UserType (Namespace ["casadi"]) (Name "Parallelizer")
extern "C"
    void delete_casadi__Parallelizer(casadi::Parallelizer* obj);
void delete_casadi__Parallelizer(casadi::Parallelizer* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Parallelizer"
// cppName: "casadi::Parallelizer"
// cWrapperName: "casadi__Parallelizer__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::Function* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Parallelizer")
// cWrapperRetType: "casadi::Parallelizer*"
// proto: "casadi::Parallelizer* casadi__Parallelizer__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::Function* >* x0)"
// call: "casadi::Parallelizer(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Function"))))]
extern "C"
    casadi::Parallelizer* casadi__Parallelizer__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::Function* >* x0);
casadi::Parallelizer* casadi__Parallelizer__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::Function* >* x0){
    try {
        std::vector< casadi::Function > x0_ = Marshaling<std::vector< casadi::Function >,std::vector< casadi::Function* >*>::marshal(x0);

        casadi::Parallelizer ret = casadi::Parallelizer(x0_);
        return WrapReturn< casadi::Parallelizer*, casadi::Parallelizer >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Parallelizer"
// cppName: "casadi::Parallelizer"
// cWrapperName: "casadi__Parallelizer__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Parallelizer")
// cWrapperRetType: "casadi::Parallelizer*"
// proto: "casadi::Parallelizer* casadi__Parallelizer__CONSTRUCTOR__1(std::string ** err_msg)"
// call: "casadi::Parallelizer()"
// params: []
extern "C"
    casadi::Parallelizer* casadi__Parallelizer__CONSTRUCTOR__1(std::string ** err_msg);
casadi::Parallelizer* casadi__Parallelizer__CONSTRUCTOR__1(std::string ** err_msg){
    try {

        casadi::Parallelizer ret = casadi::Parallelizer();
        return WrapReturn< casadi::Parallelizer*, casadi::Parallelizer >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "PrintableObject")===============
// classType: UserType (Namespace ["casadi"]) (Name "PrintableObject")
extern "C"
    void delete_casadi__PrintableObject(casadi::PrintableObject* obj);
void delete_casadi__PrintableObject(casadi::PrintableObject* obj){
    delete obj;
}

// ================== Normal method: "getDescription" ===============
// class: "casadi::PrintableObject"
// cppName: "casadi::PrintableObject::getDescription"
// cWrapperName: "casadi__PrintableObject__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::PrintableObject* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__PrintableObject__getDescription(std::string ** err_msg, casadi::PrintableObject* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__PrintableObject__getDescription(std::string ** err_msg, casadi::PrintableObject* obj);
std::string* casadi__PrintableObject__getDescription(std::string ** err_msg, casadi::PrintableObject* obj){
    try {

        std::string ret = obj->getDescription();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::PrintableObject"
// cppName: "casadi::PrintableObject::getRepresentation"
// cWrapperName: "casadi__PrintableObject__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::PrintableObject* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__PrintableObject__getRepresentation(std::string ** err_msg, casadi::PrintableObject* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__PrintableObject__getRepresentation(std::string ** err_msg, casadi::PrintableObject* obj);
std::string* casadi__PrintableObject__getRepresentation(std::string ** err_msg, casadi::PrintableObject* obj){
    try {

        std::string ret = obj->getRepresentation();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "QCQPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "QCQPSolver")
extern "C"
    void delete_casadi__QCQPSolver(casadi::QCQPSolver* obj);
void delete_casadi__QCQPSolver(casadi::QCQPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::QCQPSolver"
// cppName: "casadi::QCQPSolver"
// cWrapperName: "casadi__QCQPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "QCQPSolver")
// cWrapperRetType: "casadi::QCQPSolver*"
// proto: "casadi::QCQPSolver* casadi__QCQPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::QCQPSolver()"
// params: []
extern "C"
    casadi::QCQPSolver* casadi__QCQPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::QCQPSolver* casadi__QCQPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::QCQPSolver ret = casadi::QCQPSolver();
        return WrapReturn< casadi::QCQPSolver*, casadi::QCQPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setQPOptions" ===============
// class: "casadi::QCQPSolver"
// cppName: "casadi::QCQPSolver::setQPOptions"
// cWrapperName: "casadi__QCQPSolver__setQPOptions"
// protoArgs: "(std::string ** err_msg, casadi::QCQPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__QCQPSolver__setQPOptions(std::string ** err_msg, casadi::QCQPSolver* obj)"
// call: "obj->setQPOptions()"
// params: []
extern "C"
    void casadi__QCQPSolver__setQPOptions(std::string ** err_msg, casadi::QCQPSolver* obj);
void casadi__QCQPSolver__setQPOptions(std::string ** err_msg, casadi::QCQPSolver* obj){
    try {

    obj->setQPOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "QPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "QPSolver")
extern "C"
    void delete_casadi__QPSolver(casadi::QPSolver* obj);
void delete_casadi__QPSolver(casadi::QPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::QPSolver"
// cppName: "casadi::QPSolver"
// cWrapperName: "casadi__QPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "QPSolver")
// cWrapperRetType: "casadi::QPSolver*"
// proto: "casadi::QPSolver* casadi__QPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::QPSolver()"
// params: []
extern "C"
    casadi::QPSolver* casadi__QPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::QPSolver* casadi__QPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::QPSolver ret = casadi::QPSolver();
        return WrapReturn< casadi::QPSolver*, casadi::QPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "generateNativeCode" ===============
// class: "casadi::QPSolver"
// cppName: "casadi::QPSolver::generateNativeCode"
// cWrapperName: "casadi__QPSolver__generateNativeCode"
// protoArgs: "(std::string ** err_msg, casadi::QPSolver* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__QPSolver__generateNativeCode(std::string ** err_msg, casadi::QPSolver* obj, std::string* x0)"
// call: "obj->generateNativeCode(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__QPSolver__generateNativeCode(std::string ** err_msg, casadi::QPSolver* obj, std::string* x0);
void casadi__QPSolver__generateNativeCode(std::string ** err_msg, casadi::QPSolver* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->generateNativeCode(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setLPOptions" ===============
// class: "casadi::QPSolver"
// cppName: "casadi::QPSolver::setLPOptions"
// cWrapperName: "casadi__QPSolver__setLPOptions"
// protoArgs: "(std::string ** err_msg, casadi::QPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__QPSolver__setLPOptions(std::string ** err_msg, casadi::QPSolver* obj)"
// call: "obj->setLPOptions()"
// params: []
extern "C"
    void casadi__QPSolver__setLPOptions(std::string ** err_msg, casadi::QPSolver* obj);
void casadi__QPSolver__setLPOptions(std::string ** err_msg, casadi::QPSolver* obj){
    try {

    obj->setLPOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SDPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "SDPSolver")
extern "C"
    void delete_casadi__SDPSolver(casadi::SDPSolver* obj);
void delete_casadi__SDPSolver(casadi::SDPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SDPSolver"
// cppName: "casadi::SDPSolver"
// cWrapperName: "casadi__SDPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SDPSolver")
// cWrapperRetType: "casadi::SDPSolver*"
// proto: "casadi::SDPSolver* casadi__SDPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::SDPSolver()"
// params: []
extern "C"
    casadi::SDPSolver* casadi__SDPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::SDPSolver* casadi__SDPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::SDPSolver ret = casadi::SDPSolver();
        return WrapReturn< casadi::SDPSolver*, casadi::SDPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setSOCPOptions" ===============
// class: "casadi::SDPSolver"
// cppName: "casadi::SDPSolver::setSOCPOptions"
// cWrapperName: "casadi__SDPSolver__setSOCPOptions"
// protoArgs: "(std::string ** err_msg, casadi::SDPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SDPSolver__setSOCPOptions(std::string ** err_msg, casadi::SDPSolver* obj)"
// call: "obj->setSOCPOptions()"
// params: []
extern "C"
    void casadi__SDPSolver__setSOCPOptions(std::string ** err_msg, casadi::SDPSolver* obj);
void casadi__SDPSolver__setSOCPOptions(std::string ** err_msg, casadi::SDPSolver* obj){
    try {

    obj->setSOCPOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SDQPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "SDQPSolver")
extern "C"
    void delete_casadi__SDQPSolver(casadi::SDQPSolver* obj);
void delete_casadi__SDQPSolver(casadi::SDQPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SDQPSolver"
// cppName: "casadi::SDQPSolver"
// cWrapperName: "casadi__SDQPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SDQPSolver")
// cWrapperRetType: "casadi::SDQPSolver*"
// proto: "casadi::SDQPSolver* casadi__SDQPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::SDQPSolver()"
// params: []
extern "C"
    casadi::SDQPSolver* casadi__SDQPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::SDQPSolver* casadi__SDQPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::SDQPSolver ret = casadi::SDQPSolver();
        return WrapReturn< casadi::SDQPSolver*, casadi::SDQPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setSOCQPOptions" ===============
// class: "casadi::SDQPSolver"
// cppName: "casadi::SDQPSolver::setSOCQPOptions"
// cWrapperName: "casadi__SDQPSolver__setSOCQPOptions"
// protoArgs: "(std::string ** err_msg, casadi::SDQPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SDQPSolver__setSOCQPOptions(std::string ** err_msg, casadi::SDQPSolver* obj)"
// call: "obj->setSOCQPOptions()"
// params: []
extern "C"
    void casadi__SDQPSolver__setSOCQPOptions(std::string ** err_msg, casadi::SDQPSolver* obj);
void casadi__SDQPSolver__setSOCQPOptions(std::string ** err_msg, casadi::SDQPSolver* obj){
    try {

    obj->setSOCQPOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SOCPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "SOCPSolver")
extern "C"
    void delete_casadi__SOCPSolver(casadi::SOCPSolver* obj);
void delete_casadi__SOCPSolver(casadi::SOCPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SOCPSolver"
// cppName: "casadi::SOCPSolver"
// cWrapperName: "casadi__SOCPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SOCPSolver")
// cWrapperRetType: "casadi::SOCPSolver*"
// proto: "casadi::SOCPSolver* casadi__SOCPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::SOCPSolver()"
// params: []
extern "C"
    casadi::SOCPSolver* casadi__SOCPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::SOCPSolver* casadi__SOCPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::SOCPSolver ret = casadi::SOCPSolver();
        return WrapReturn< casadi::SOCPSolver*, casadi::SOCPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SX")===============
// classType: UserType (Namespace ["casadi"]) (Name "SX")
extern "C"
    void delete_casadi__SX(casadi::SX* obj);
void delete_casadi__SX(casadi::SX* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0, int x1, int x2)"
// call: "casadi::SX(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CDouble)),CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0, int x1, int x2);
casadi::SX* casadi__SX__CONSTRUCTOR__0(std::string ** err_msg, std::vector< double >* x0, int x1, int x2){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::SX(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__1(std::string ** err_msg, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, casadi::DMatrix* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, casadi::DMatrix* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__2(std::string ** err_msg, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, std::vector< int >* x0, int x1, int x2)"
// call: "casadi::SX(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CInt)),CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, std::vector< int >* x0, int x1, int x2);
casadi::SX* casadi__SX__CONSTRUCTOR__3(std::string ** err_msg, std::vector< int >* x0, int x1, int x2){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::SX(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< int >* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__4(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, casadi::IMatrix* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, casadi::IMatrix* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__5(std::string ** err_msg, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__6"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, int x1, int x2)"
// call: "casadi::SX(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, int x1, int x2);
casadi::SX* casadi__SX__CONSTRUCTOR__6(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, int x1, int x2){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::SX(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__7"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SXElement* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, std::vector< casadi::SXElement* >* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, std::vector< casadi::SXElement* >* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__7(std::string ** err_msg, std::vector< casadi::SXElement* >* x0){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__8"
// protoArgs: "(std::string ** err_msg, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, double x0)"
// call: "casadi::SX(x0_)"
// params: [CDouble]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, double x0);
casadi::SX* casadi__SX__CONSTRUCTOR__8(std::string ** err_msg, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__9"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, std::vector< casadi::SXElement* >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::Sparsity* x0, std::vector< casadi::SXElement* >* x1)"
// call: "casadi::SX(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::Sparsity* x0, std::vector< casadi::SXElement* >* x1);
casadi::SX* casadi__SX__CONSTRUCTOR__9(std::string ** err_msg, casadi::Sparsity* x0, std::vector< casadi::SXElement* >* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::vector< casadi::SXElement > x1_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x1);

        casadi::SX ret = casadi::SX(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__10"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__10(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__10(std::string ** err_msg, casadi::Sparsity* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__10(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__11"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, casadi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__11(std::string ** err_msg, casadi::Sparsity* x0, casadi::SXElement* x1)"
// call: "casadi::SX(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__11(std::string ** err_msg, casadi::Sparsity* x0, casadi::SXElement* x1);
casadi::SX* casadi__SX__CONSTRUCTOR__11(std::string ** err_msg, casadi::Sparsity* x0, casadi::SXElement* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

        casadi::SX ret = casadi::SX(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__12"
// protoArgs: "(std::string ** err_msg, std::vector< std::vector< casadi::SXElement* >* >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__12(std::string ** err_msg, std::vector< std::vector< casadi::SXElement* >* >* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__12(std::string ** err_msg, std::vector< std::vector< casadi::SXElement* >* >* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__12(std::string ** err_msg, std::vector< std::vector< casadi::SXElement* >* >* x0){
    try {
        std::vector< std::vector< casadi::SXElement > > x0_ = Marshaling<std::vector< std::vector< casadi::SXElement > >,std::vector< std::vector< casadi::SXElement* >* >*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__13"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__13(std::string ** err_msg, casadi::SX* x0)"
// call: "casadi::SX(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__13(std::string ** err_msg, casadi::SX* x0);
casadi::SX* casadi__SX__CONSTRUCTOR__13(std::string ** err_msg, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = casadi::SX(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SX"
// cppName: "casadi::SX"
// cWrapperName: "casadi__SX__CONSTRUCTOR__14"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__CONSTRUCTOR__14(std::string ** err_msg)"
// call: "casadi::SX()"
// params: []
extern "C"
    casadi::SX* casadi__SX__CONSTRUCTOR__14(std::string ** err_msg);
casadi::SX* casadi__SX__CONSTRUCTOR__14(std::string ** err_msg){
    try {

        casadi::SX ret = casadi::SX();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__add__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__add__"
// cWrapperName: "casadi__SX____add__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____add__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__add__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____add__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____add__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__add__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__constpow__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__constpow__"
// cWrapperName: "casadi__SX____constpow__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____constpow__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__constpow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____constpow__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____constpow__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__constpow__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__copysign__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__copysign__"
// cWrapperName: "casadi__SX____copysign__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____copysign__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__copysign__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____copysign__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____copysign__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__copysign__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__div__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__div__"
// cWrapperName: "casadi__SX____div__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____div__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__div__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____div__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____div__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__div__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__eq__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__eq__"
// cWrapperName: "casadi__SX____eq__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____eq__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__eq__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____eq__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____eq__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__eq__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__ge__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__ge__"
// cWrapperName: "casadi__SX____ge__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____ge__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__ge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____ge__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____ge__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__ge__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__gt__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__gt__"
// cWrapperName: "casadi__SX____gt__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____gt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__gt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____gt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____gt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__gt__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__le__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__le__"
// cWrapperName: "casadi__SX____le__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____le__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__le__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____le__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____le__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__le__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__lt__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__lt__"
// cWrapperName: "casadi__SX____lt__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____lt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__lt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____lt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____lt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__lt__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mldivide__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__mldivide__"
// cWrapperName: "casadi__SX____mldivide__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____mldivide__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__mldivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____mldivide__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____mldivide__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__mldivide__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mpower__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__mpower__"
// cWrapperName: "casadi__SX____mpower__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____mpower__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__mpower__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____mpower__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____mpower__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__mpower__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mrdivide__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__mrdivide__"
// cWrapperName: "casadi__SX____mrdivide__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____mrdivide__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__mrdivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____mrdivide__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____mrdivide__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__mrdivide__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mul__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__mul__"
// cWrapperName: "casadi__SX____mul__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____mul__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__mul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____mul__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____mul__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__mul__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__ne__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__ne__"
// cWrapperName: "casadi__SX____ne__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____ne__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__ne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____ne__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____ne__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__ne__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__nonzero__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__nonzero__"
// cWrapperName: "casadi__SX____nonzero__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->__nonzero__()"
// params: []
extern "C"
    int casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj);
int casadi__SX____nonzero__(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->__nonzero__();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__pow__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__pow__"
// cWrapperName: "casadi__SX____pow__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____pow__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__pow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____pow__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____pow__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__pow__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__radd__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__radd__"
// cWrapperName: "casadi__SX____radd__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____radd__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__radd__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____radd__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____radd__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__radd__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rdiv__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rdiv__"
// cWrapperName: "casadi__SX____rdiv__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rdiv__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rdiv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rdiv__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rdiv__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rdiv__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__req__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__req__"
// cWrapperName: "casadi__SX____req__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____req__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__req__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____req__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____req__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__req__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rge__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rge__"
// cWrapperName: "casadi__SX____rge__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rge__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rge__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rge__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rge__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rgt__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rgt__"
// cWrapperName: "casadi__SX____rgt__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rgt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rgt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rgt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rgt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rgt__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rle__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rle__"
// cWrapperName: "casadi__SX____rle__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rle__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rle__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rle__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rle__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rle__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rlt__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rlt__"
// cWrapperName: "casadi__SX____rlt__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rlt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rlt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rlt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rlt__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rlt__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rmul__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rmul__"
// cWrapperName: "casadi__SX____rmul__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rmul__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rmul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rmul__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rmul__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rmul__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rne__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rne__"
// cWrapperName: "casadi__SX____rne__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rne__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rne__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rne__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rne__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rsub__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rsub__"
// cWrapperName: "casadi__SX____rsub__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rsub__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rsub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rsub__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rsub__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rsub__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rtruediv__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__rtruediv__"
// cWrapperName: "casadi__SX____rtruediv__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____rtruediv__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__rtruediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____rtruediv__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____rtruediv__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__rtruediv__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__sub__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__sub__"
// cWrapperName: "casadi__SX____sub__"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____sub__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__sub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____sub__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____sub__(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__sub__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__truediv__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__truediv__"
// cWrapperName: "casadi__SX____truediv____0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____truediv____0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____truediv____0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____truediv____0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__truediv__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__truediv__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__truediv__"
// cWrapperName: "casadi__SX____truediv____1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX____truediv____1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX____truediv____1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____truediv____1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__truediv__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "append" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::append"
// cWrapperName: "casadi__SX__append"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__append(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->append(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__append(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
void casadi__SX__append(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    obj->append(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "appendColumns" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::appendColumns"
// cWrapperName: "casadi__SX__appendColumns"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__appendColumns(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->appendColumns(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__appendColumns(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
void casadi__SX__appendColumns(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    obj->appendColumns(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "arccos" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arccos"
// cWrapperName: "casadi__SX__arccos"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arccos(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->arccos()"
// params: []
extern "C"
    casadi::SX* casadi__SX__arccos(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__arccos(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->arccos();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arccosh" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arccosh"
// cWrapperName: "casadi__SX__arccosh"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arccosh(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->arccosh()"
// params: []
extern "C"
    casadi::SX* casadi__SX__arccosh(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__arccosh(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->arccosh();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arcsin" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arcsin"
// cWrapperName: "casadi__SX__arcsin"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arcsin(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->arcsin()"
// params: []
extern "C"
    casadi::SX* casadi__SX__arcsin(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__arcsin(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->arcsin();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arcsinh" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arcsinh"
// cWrapperName: "casadi__SX__arcsinh"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arcsinh(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->arcsinh()"
// params: []
extern "C"
    casadi::SX* casadi__SX__arcsinh(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__arcsinh(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->arcsinh();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctan" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arctan"
// cWrapperName: "casadi__SX__arctan"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arctan(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->arctan()"
// params: []
extern "C"
    casadi::SX* casadi__SX__arctan(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__arctan(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->arctan();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctan2" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arctan2"
// cWrapperName: "casadi__SX__arctan2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arctan2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->arctan2(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__arctan2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__arctan2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->arctan2(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctanh" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::arctanh"
// cWrapperName: "casadi__SX__arctanh"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__arctanh(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->arctanh()"
// params: []
extern "C"
    casadi::SX* casadi__SX__arctanh(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__arctanh(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->arctanh();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "at" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::at"
// cWrapperName: "casadi__SX__at"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__at(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->at(x0_)"
// params: [CInt]
extern "C"
    casadi::SXElement* casadi__SX__at(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SXElement* casadi__SX__at(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SXElement ret = obj->at(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "binary" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::binary"
// cWrapperName: "casadi__SX__binary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::binary(x0_, x1_, x2_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* casadi__SX__binary(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
    try {
        int x0_ = Marshaling<int,int>::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::SX::binary(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "ceil" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::ceil"
// cWrapperName: "casadi__SX__ceil"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__ceil(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->ceil()"
// params: []
extern "C"
    casadi::SX* casadi__SX__ceil(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__ceil(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->ceil();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "className" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::className"
// cWrapperName: "casadi__SX__className"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SX__className(std::string ** err_msg)"
// call: "casadi::SX::className()"
// params: []
extern "C"
    std::string* casadi__SX__className(std::string ** err_msg);
std::string* casadi__SX__className(std::string ** err_msg){
    try {

        std::string ret = casadi::SX::className();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "clear" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::clear"
// cWrapperName: "casadi__SX__clear"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__clear(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->clear()"
// params: []
extern "C"
    void casadi__SX__clear(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__clear(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->clear();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "colind" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::colind"
// cWrapperName: "casadi__SX__colind__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__colind__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->colind(x0_)"
// params: [CInt]
extern "C"
    int casadi__SX__colind__0(std::string ** err_msg, casadi::SX* obj, int x0);
int casadi__SX__colind__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        int ret = obj->colind(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "colind" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::colind"
// cWrapperName: "casadi__SX__colind__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__SX__colind__1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->colind()"
// params: []
extern "C"
    std::vector< int >* casadi__SX__colind__1(std::string ** err_msg, casadi::SX* obj);
std::vector< int >* casadi__SX__colind__1(std::string ** err_msg, casadi::SX* obj){
    try {

        std::vector< int > ret = obj->colind();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "cos" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::cos"
// cWrapperName: "casadi__SX__cos"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__cos(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->cos()"
// params: []
extern "C"
    casadi::SX* casadi__SX__cos(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__cos(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->cos();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "cosh" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::cosh"
// cWrapperName: "casadi__SX__cosh"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__cosh(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->cosh()"
// params: []
extern "C"
    casadi::SX* casadi__SX__cosh(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__cosh(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->cosh();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "data" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::data"
// cWrapperName: "casadi__SX__data__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))
// cWrapperRetType: "std::vector< casadi::SXElement* >*"
// proto: "std::vector< casadi::SXElement* >* casadi__SX__data__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->data()"
// params: []
extern "C"
    std::vector< casadi::SXElement* >* casadi__SX__data__0(std::string ** err_msg, casadi::SX* obj);
std::vector< casadi::SXElement* >* casadi__SX__data__0(std::string ** err_msg, casadi::SX* obj){
    try {

        std::vector< casadi::SXElement > ret = obj->data();
        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;
    }
}


// ================== Normal method: "data" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::data"
// cWrapperName: "casadi__SX__data__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))
// cWrapperRetType: "std::vector< casadi::SXElement* >*"
// proto: "std::vector< casadi::SXElement* >* casadi__SX__data__1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->data()"
// params: []
extern "C"
    std::vector< casadi::SXElement* >* casadi__SX__data__1(std::string ** err_msg, casadi::SX* obj);
std::vector< casadi::SXElement* >* casadi__SX__data__1(std::string ** err_msg, casadi::SX* obj){
    try {

        std::vector< casadi::SXElement > ret = obj->data();
        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;
    }
}


// ================== Normal method: "densify" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::densify"
// cWrapperName: "casadi__SX__densify__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__densify__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->densify()"
// params: []
extern "C"
    void casadi__SX__densify__0(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__densify__0(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->densify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "densify" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::densify"
// cWrapperName: "casadi__SX__densify__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__densify__1(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// call: "obj->densify(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__densify__1(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0);
void casadi__SX__densify__1(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

    obj->densify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "dimString" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::dimString"
// cWrapperName: "casadi__SX__dimString"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SX__dimString(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->dimString()"
// params: []
extern "C"
    std::string* casadi__SX__dimString(std::string ** err_msg, casadi::SX* obj);
std::string* casadi__SX__dimString(std::string ** err_msg, casadi::SX* obj){
    try {

        std::string ret = obj->dimString();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "elem" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::elem"
// cWrapperName: "casadi__SX__elem__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__elem__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->elem(x0_)"
// params: [CInt]
extern "C"
    casadi::SXElement* casadi__SX__elem__0(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SXElement* casadi__SX__elem__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SXElement ret = obj->elem(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "elem" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::elem"
// cWrapperName: "casadi__SX__elem__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__elem__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->elem(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SXElement* casadi__SX__elem__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
casadi::SXElement* casadi__SX__elem__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SXElement ret = obj->elem(x0_, x1_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "enlarge" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::enlarge"
// cWrapperName: "casadi__SX__enlarge"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__enlarge(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__enlarge(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void casadi__SX__enlarge(std::string ** err_msg, casadi::SX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

    obj->enlarge(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "erase" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::erase"
// cWrapperName: "casadi__SX__erase"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__erase(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__erase(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__SX__erase(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->erase(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "erf" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::erf"
// cWrapperName: "casadi__SX__erf"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__erf(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->erf()"
// params: []
extern "C"
    casadi::SX* casadi__SX__erf(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__erf(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->erf();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "erfinv" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::erfinv"
// cWrapperName: "casadi__SX__erfinv"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__erfinv(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->erfinv()"
// params: []
extern "C"
    casadi::SX* casadi__SX__erfinv(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__erfinv(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->erfinv();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "exp" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::exp"
// cWrapperName: "casadi__SX__exp"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__exp(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->exp()"
// params: []
extern "C"
    casadi::SX* casadi__SX__exp(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__exp(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->exp();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "eye" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::eye"
// cWrapperName: "casadi__SX__eye"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__eye(std::string ** err_msg, int x0)"
// call: "casadi::SX::eye(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__eye(std::string ** err_msg, int x0);
casadi::SX* casadi__SX__eye(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = casadi::SX::eye(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fabs" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::fabs"
// cWrapperName: "casadi__SX__fabs"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__fabs(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->fabs()"
// params: []
extern "C"
    casadi::SX* casadi__SX__fabs(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__fabs(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->fabs();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "floor" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::floor"
// cWrapperName: "casadi__SX__floor"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__floor(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->floor()"
// params: []
extern "C"
    casadi::SX* casadi__SX__floor(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__floor(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->floor();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmax" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::fmax"
// cWrapperName: "casadi__SX__fmax"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__fmax(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->fmax(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__fmax(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__fmax(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->fmax(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmin" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::fmin"
// cWrapperName: "casadi__SX__fmin"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__fmin(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->fmin(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__fmin(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__fmin(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->fmin(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmod" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::fmod"
// cWrapperName: "casadi__SX__fmod"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__fmod(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->fmod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__fmod(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__fmod(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->fmod(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::get"
// cWrapperName: "casadi__SX__get__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->get(x0_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
extern "C"
    void casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
void casadi__SX__get__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::get"
// cWrapperName: "casadi__SX__get__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SX")),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1);
void casadi__SX__get__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::get"
// cWrapperName: "casadi__SX__get__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0)"
// call: "obj->get(x0_)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0);
void casadi__SX__get__2(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::get"
// cWrapperName: "casadi__SX__get__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1);
void casadi__SX__get__3(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::get"
// cWrapperName: "casadi__SX__get__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// call: "obj->get(x0_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SXElement"))]
extern "C"
    void casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0);
void casadi__SX__get__4(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

    obj->get(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "get" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::get"
// cWrapperName: "casadi__SX__get__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1)"
// call: "obj->get(x0_, x1_)"
// params: [Ref (UserType (Namespace ["casadi"]) (Name "SXElement")),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1);
void casadi__SX__get__5(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->get(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getElement" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getElement"
// cWrapperName: "casadi__SX__getElement__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SXElement"))
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__getElement__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->getElement(x0_)"
// params: [CInt]
extern "C"
    casadi::SXElement* casadi__SX__getElement__0(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SXElement* casadi__SX__getElement__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SXElement ret = obj->getElement(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getElement" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getElement"
// cWrapperName: "casadi__SX__getElement__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SXElement"))
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__getElement__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->getElement(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SXElement* casadi__SX__getElement__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
casadi::SXElement* casadi__SX__getElement__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SXElement ret = obj->getElement(x0_, x1_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getEqualityCheckingDepth"
// cWrapperName: "casadi__SX__getEqualityCheckingDepth"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__getEqualityCheckingDepth(std::string ** err_msg)"
// call: "casadi::SX::getEqualityCheckingDepth()"
// params: []
extern "C"
    int casadi__SX__getEqualityCheckingDepth(std::string ** err_msg);
int casadi__SX__getEqualityCheckingDepth(std::string ** err_msg){
    try {

        int ret = casadi::SX::getEqualityCheckingDepth();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getMaxNumCallsInPrint"
// cWrapperName: "casadi__SX__getMaxNumCallsInPrint"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long casadi__SX__getMaxNumCallsInPrint(std::string ** err_msg)"
// call: "casadi::SX::getMaxNumCallsInPrint()"
// params: []
extern "C"
    long casadi__SX__getMaxNumCallsInPrint(std::string ** err_msg);
long casadi__SX__getMaxNumCallsInPrint(std::string ** err_msg){
    try {

        long ret = casadi::SX::getMaxNumCallsInPrint();
        return WrapReturn< long, long >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getNZ"
// cWrapperName: "casadi__SX__getNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__getNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__getNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0);
casadi::SX* casadi__SX__getNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::SX ret = obj->getNZ(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getNZ"
// cWrapperName: "casadi__SX__getNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__getNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__getNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0);
casadi::SX* casadi__SX__getNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

        casadi::SX ret = obj->getNZ(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getNZ"
// cWrapperName: "casadi__SX__getNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__getNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0)"
// call: "obj->getNZ(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::SX* casadi__SX__getNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0);
casadi::SX* casadi__SX__getNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::SX ret = obj->getNZ(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getNZ"
// cWrapperName: "casadi__SX__getNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__getNZ__3(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->getNZ(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__getNZ__3(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SX* casadi__SX__getNZ__3(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->getNZ(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getName" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getName"
// cWrapperName: "casadi__SX__getName"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SX__getName(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->getName()"
// params: []
extern "C"
    std::string* casadi__SX__getName(std::string ** err_msg, casadi::SX* obj);
std::string* casadi__SX__getName(std::string ** err_msg, casadi::SX* obj){
    try {

        std::string ret = obj->getName();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getValue" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getValue"
// cWrapperName: "casadi__SX__getValue"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__SX__getValue(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->getValue()"
// params: []
extern "C"
    double casadi__SX__getValue(std::string ** err_msg, casadi::SX* obj);
double casadi__SX__getValue(std::string ** err_msg, casadi::SX* obj){
    try {

        double ret = obj->getValue();
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hasNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::hasNZ"
// cWrapperName: "casadi__SX__hasNZ"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__hasNZ(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__SX__hasNZ(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
int casadi__SX__hasNZ(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        bool ret = obj->hasNZ(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hasNonStructuralZeros" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::hasNonStructuralZeros"
// cWrapperName: "casadi__SX__hasNonStructuralZeros"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__hasNonStructuralZeros(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->hasNonStructuralZeros()"
// params: []
extern "C"
    int casadi__SX__hasNonStructuralZeros(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__hasNonStructuralZeros(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->hasNonStructuralZeros();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "if_else_zero" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::if_else_zero"
// cWrapperName: "casadi__SX__if_else_zero"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__if_else_zero(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->if_else_zero(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__if_else_zero(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__if_else_zero(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->if_else_zero(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed"
// cWrapperName: "casadi__SX__indexed__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed__0(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__indexed__0(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0);
casadi::SX* casadi__SX__indexed__0(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

        casadi::SX ret = obj->indexed(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed"
// cWrapperName: "casadi__SX__indexed__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0)"
// call: "obj->indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__indexed__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0);
casadi::SX* casadi__SX__indexed__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = obj->indexed(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed"
// cWrapperName: "casadi__SX__indexed__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__indexed__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::SX* casadi__SX__indexed__2(std::string ** err_msg, casadi::SX* obj, 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::SX ret = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed"
// cWrapperName: "casadi__SX__indexed__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed__3(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__indexed__3(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::SX* casadi__SX__indexed__3(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::SX ret = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed"
// cWrapperName: "casadi__SX__indexed__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed__4(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__indexed__4(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::SX* casadi__SX__indexed__4(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::SX ret = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed"
// cWrapperName: "casadi__SX__indexed__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed__5(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->indexed(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__indexed__5(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::SX* casadi__SX__indexed__5(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::SX ret = obj->indexed(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_assignment"
// cWrapperName: "casadi__SX__indexed_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1);
void casadi__SX__indexed_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_assignment"
// cWrapperName: "casadi__SX__indexed_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_assignment__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, casadi::SX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_assignment__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, casadi::SX* x1);
void casadi__SX__indexed_assignment__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, casadi::SX* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_assignment"
// cWrapperName: "casadi__SX__indexed_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::SX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::SX* x2);
void casadi__SX__indexed_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::SX* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_assignment"
// cWrapperName: "casadi__SX__indexed_assignment__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_assignment__3(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::SX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_assignment__3(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::SX* x2);
void casadi__SX__indexed_assignment__3(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1, casadi::SX* x2){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_assignment"
// cWrapperName: "casadi__SX__indexed_assignment__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_assignment__4(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::SX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_assignment__4(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::SX* x2);
void casadi__SX__indexed_assignment__4(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1, casadi::SX* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_assignment"
// cWrapperName: "casadi__SX__indexed_assignment__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_assignment__5(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::SX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_assignment__5(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::SX* x2);
void casadi__SX__indexed_assignment__5(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1, casadi::SX* x2){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_one_based"
// cWrapperName: "casadi__SX__indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed_one_based__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__indexed_one_based__0(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SX* casadi__SX__indexed_one_based__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->indexed_one_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_one_based"
// cWrapperName: "casadi__SX__indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed_one_based__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->indexed_one_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__indexed_one_based__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
casadi::SX* casadi__SX__indexed_one_based__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->indexed_one_based(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_one_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_one_based"
// cWrapperName: "casadi__SX__indexed_one_based__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed_one_based__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// call: "obj->indexed_one_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__indexed_one_based__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0);
casadi::SX* casadi__SX__indexed_one_based__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::SX ret = obj->indexed_one_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_one_based_assignment"
// cWrapperName: "casadi__SX__indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_one_based_assignment__0(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__indexed_one_based_assignment__0(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1);
void casadi__SX__indexed_one_based_assignment__0(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_one_based_assignment"
// cWrapperName: "casadi__SX__indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_one_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__indexed_one_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2);
void casadi__SX__indexed_one_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::SXElement x2_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_one_based_assignment"
// cWrapperName: "casadi__SX__indexed_one_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_one_based_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_one_based_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1);
void casadi__SX__indexed_one_based_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_zero_based"
// cWrapperName: "casadi__SX__indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed_zero_based__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__indexed_zero_based__0(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SX* casadi__SX__indexed_zero_based__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->indexed_zero_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_zero_based"
// cWrapperName: "casadi__SX__indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed_zero_based__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->indexed_zero_based(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__indexed_zero_based__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
casadi::SX* casadi__SX__indexed_zero_based__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->indexed_zero_based(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_zero_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_zero_based"
// cWrapperName: "casadi__SX__indexed_zero_based__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__indexed_zero_based__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// call: "obj->indexed_zero_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__indexed_zero_based__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0);
casadi::SX* casadi__SX__indexed_zero_based__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::SX ret = obj->indexed_zero_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_zero_based_assignment"
// cWrapperName: "casadi__SX__indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1);
void casadi__SX__indexed_zero_based_assignment__0(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_zero_based_assignment"
// cWrapperName: "casadi__SX__indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
// params: [CInt,CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2);
void casadi__SX__indexed_zero_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, int x1, casadi::SXElement* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::SXElement x2_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::indexed_zero_based_assignment"
// cWrapperName: "casadi__SX__indexed_zero_based_assignment__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1);
void casadi__SX__indexed_zero_based_assignment__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::inf"
// cWrapperName: "casadi__SX__inf__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__inf__0(std::string ** err_msg)"
// call: "casadi::SX::inf()"
// params: []
extern "C"
    casadi::SX* casadi__SX__inf__0(std::string ** err_msg);
casadi::SX* casadi__SX__inf__0(std::string ** err_msg){
    try {

        casadi::SX ret = casadi::SX::inf();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::inf"
// cWrapperName: "casadi__SX__inf__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__inf__1(std::string ** err_msg, int x0)"
// call: "casadi::SX::inf(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__inf__1(std::string ** err_msg, int x0);
casadi::SX* casadi__SX__inf__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = casadi::SX::inf(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::inf"
// cWrapperName: "casadi__SX__inf__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__inf__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::SX::inf(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__inf__2(std::string ** err_msg, int x0, int x1);
casadi::SX* casadi__SX__inf__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = casadi::SX::inf(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "inf" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::inf"
// cWrapperName: "casadi__SX__inf__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__inf__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::SX::inf(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__inf__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::SX* casadi__SX__inf__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = casadi::SX::inf(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isConstant" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isConstant"
// cWrapperName: "casadi__SX__isConstant"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isConstant(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isConstant()"
// params: []
extern "C"
    int casadi__SX__isConstant(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isConstant(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isConstant();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isDense" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isDense"
// cWrapperName: "casadi__SX__isDense"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isDense(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isDense()"
// params: []
extern "C"
    int casadi__SX__isDense(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isDense(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isDense();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEmpty" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isEmpty"
// cWrapperName: "casadi__SX__isEmpty__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isEmpty__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isEmpty()"
// params: []
extern "C"
    int casadi__SX__isEmpty__0(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isEmpty__0(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isEmpty();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEmpty" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isEmpty"
// cWrapperName: "casadi__SX__isEmpty__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isEmpty__1(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->isEmpty(x0_)"
// params: [CBool]
extern "C"
    int casadi__SX__isEmpty__1(std::string ** err_msg, casadi::SX* obj, int x0);
int casadi__SX__isEmpty__1(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        bool ret = obj->isEmpty(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEqual" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isEqual"
// cWrapperName: "casadi__SX__isEqual"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isEqual(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->isEqual(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    int casadi__SX__isEqual(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
int casadi__SX__isEqual(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        bool ret = obj->isEqual(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isIdentity" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isIdentity"
// cWrapperName: "casadi__SX__isIdentity"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isIdentity(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isIdentity()"
// params: []
extern "C"
    int casadi__SX__isIdentity(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isIdentity(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isIdentity();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isInteger" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isInteger"
// cWrapperName: "casadi__SX__isInteger"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isInteger(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isInteger()"
// params: []
extern "C"
    int casadi__SX__isInteger(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isInteger(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isInteger();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isMinusOne" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isMinusOne"
// cWrapperName: "casadi__SX__isMinusOne"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isMinusOne(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isMinusOne()"
// params: []
extern "C"
    int casadi__SX__isMinusOne(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isMinusOne(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isMinusOne();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isOne" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isOne"
// cWrapperName: "casadi__SX__isOne"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isOne(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isOne()"
// params: []
extern "C"
    int casadi__SX__isOne(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isOne(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isOne();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isRegular" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isRegular"
// cWrapperName: "casadi__SX__isRegular"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isRegular(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isRegular()"
// params: []
extern "C"
    int casadi__SX__isRegular(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isRegular(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isRegular();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isScalar" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isScalar"
// cWrapperName: "casadi__SX__isScalar__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isScalar__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isScalar()"
// params: []
extern "C"
    int casadi__SX__isScalar__0(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isScalar__0(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isScalar();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isScalar" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isScalar"
// cWrapperName: "casadi__SX__isScalar__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isScalar__1(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->isScalar(x0_)"
// params: [CBool]
extern "C"
    int casadi__SX__isScalar__1(std::string ** err_msg, casadi::SX* obj, int x0);
int casadi__SX__isScalar__1(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        bool ret = obj->isScalar(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSmooth" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isSmooth"
// cWrapperName: "casadi__SX__isSmooth"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isSmooth(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isSmooth()"
// params: []
extern "C"
    int casadi__SX__isSmooth(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isSmooth(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isSmooth();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSquare" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isSquare"
// cWrapperName: "casadi__SX__isSquare"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isSquare(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isSquare()"
// params: []
extern "C"
    int casadi__SX__isSquare(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isSquare(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isSquare();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSymbolic" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isSymbolic"
// cWrapperName: "casadi__SX__isSymbolic"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isSymbolic(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isSymbolic()"
// params: []
extern "C"
    int casadi__SX__isSymbolic(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isSymbolic(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isSymbolic();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSymbolicSparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isSymbolicSparse"
// cWrapperName: "casadi__SX__isSymbolicSparse"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isSymbolicSparse(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isSymbolicSparse()"
// params: []
extern "C"
    int casadi__SX__isSymbolicSparse(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isSymbolicSparse(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isSymbolicSparse();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isTril" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isTril"
// cWrapperName: "casadi__SX__isTril"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isTril(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isTril()"
// params: []
extern "C"
    int casadi__SX__isTril(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isTril(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isTril();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isTriu" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isTriu"
// cWrapperName: "casadi__SX__isTriu"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isTriu(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isTriu()"
// params: []
extern "C"
    int casadi__SX__isTriu(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isTriu(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isTriu();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isVector" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isVector"
// cWrapperName: "casadi__SX__isVector"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isVector(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isVector()"
// params: []
extern "C"
    int casadi__SX__isVector(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isVector(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isVector();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isZero" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::isZero"
// cWrapperName: "casadi__SX__isZero"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SX__isZero(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->isZero()"
// params: []
extern "C"
    int casadi__SX__isZero(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__isZero(std::string ** err_msg, casadi::SX* obj){
    try {

        bool ret = obj->isZero();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "log" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::log"
// cWrapperName: "casadi__SX__log"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__log(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->log()"
// params: []
extern "C"
    casadi::SX* casadi__SX__log(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__log(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->log();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "log10" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::log10"
// cWrapperName: "casadi__SX__log10"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__log10(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->log10()"
// params: []
extern "C"
    casadi::SX* casadi__SX__log10(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__log10(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->log10();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "logic_and" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::logic_and"
// cWrapperName: "casadi__SX__logic_and"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__logic_and(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->logic_and(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__logic_and(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__logic_and(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->logic_and(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "logic_not" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::logic_not"
// cWrapperName: "casadi__SX__logic_not"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__logic_not(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->logic_not()"
// params: []
extern "C"
    casadi::SX* casadi__SX__logic_not(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__logic_not(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->logic_not();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "logic_or" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::logic_or"
// cWrapperName: "casadi__SX__logic_or"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__logic_or(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->logic_or(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__logic_or(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__logic_or(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->logic_or(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "matrix_matrix" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::matrix_matrix"
// cWrapperName: "casadi__SX__matrix_matrix"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::matrix_matrix(x0_, x1_, x2_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* casadi__SX__matrix_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
    try {
        int x0_ = Marshaling<int,int>::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::SX::matrix_matrix(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "matrix_scalar" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::matrix_scalar"
// cWrapperName: "casadi__SX__matrix_scalar"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::matrix_scalar(x0_, x1_, x2_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* casadi__SX__matrix_scalar(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
    try {
        int x0_ = Marshaling<int,int>::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::SX::matrix_scalar(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul"
// cWrapperName: "casadi__SX__mul__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__mul__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->mul(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__mul__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__mul__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->mul(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul"
// cWrapperName: "casadi__SX__mul__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__mul__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__mul__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1);
casadi::SX* casadi__SX__mul__1(std::string ** err_msg, casadi::SX* obj, 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 = obj->mul(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul_full" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_full"
// cWrapperName: "casadi__SX__mul_full__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__mul_full__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->mul_full(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__mul_full__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__mul_full__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->mul_full(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul_full" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_full"
// cWrapperName: "casadi__SX__mul_full__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__mul_full__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__mul_full__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1);
casadi::SX* casadi__SX__mul_full__1(std::string ** err_msg, casadi::SX* obj, 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 = obj->mul_full(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_no_alloc_nn"
// cWrapperName: "casadi__SX__mul_no_alloc_nn__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__mul_no_alloc_nn__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// call: "casadi::SX::mul_no_alloc_nn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__mul_no_alloc_nn__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2);
void casadi__SX__mul_no_alloc_nn__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::SX::mul_no_alloc_nn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_no_alloc_nn"
// cWrapperName: "casadi__SX__mul_no_alloc_nn__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__mul_no_alloc_nn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::mul_no_alloc_nn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
extern "C"
    void casadi__SX__mul_no_alloc_nn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
void casadi__SX__mul_no_alloc_nn__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::mul_no_alloc_nn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "mul_no_alloc_nt" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_no_alloc_nt"
// cWrapperName: "casadi__SX__mul_no_alloc_nt"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__mul_no_alloc_nt(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::mul_no_alloc_nt(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
extern "C"
    void casadi__SX__mul_no_alloc_nt(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
void casadi__SX__mul_no_alloc_nt(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::mul_no_alloc_nt(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_no_alloc_tn"
// cWrapperName: "casadi__SX__mul_no_alloc_tn__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__mul_no_alloc_tn__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2)"
// call: "casadi::SX::mul_no_alloc_tn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__mul_no_alloc_tn__0(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1, std::vector< casadi::SXElement* >* x2);
void casadi__SX__mul_no_alloc_tn__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::SX::mul_no_alloc_tn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_no_alloc_tn"
// cWrapperName: "casadi__SX__mul_no_alloc_tn__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__mul_no_alloc_tn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::mul_no_alloc_tn(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX"))]
extern "C"
    void casadi__SX__mul_no_alloc_tn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
void casadi__SX__mul_no_alloc_tn__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::mul_no_alloc_tn(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "mul_smart" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::mul_smart"
// cWrapperName: "casadi__SX__mul_smart"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__mul_smart(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__mul_smart(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1);
casadi::SX* casadi__SX__mul_smart(std::string ** err_msg, casadi::SX* obj, 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 = obj->mul_smart(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nan"
// cWrapperName: "casadi__SX__nan__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nan__0(std::string ** err_msg)"
// call: "casadi::SX::nan()"
// params: []
extern "C"
    casadi::SX* casadi__SX__nan__0(std::string ** err_msg);
casadi::SX* casadi__SX__nan__0(std::string ** err_msg){
    try {

        casadi::SX ret = casadi::SX::nan();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nan"
// cWrapperName: "casadi__SX__nan__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nan__1(std::string ** err_msg, int x0)"
// call: "casadi::SX::nan(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__nan__1(std::string ** err_msg, int x0);
casadi::SX* casadi__SX__nan__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = casadi::SX::nan(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nan"
// cWrapperName: "casadi__SX__nan__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nan__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::SX::nan(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__nan__2(std::string ** err_msg, int x0, int x1);
casadi::SX* casadi__SX__nan__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = casadi::SX::nan(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "nan" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nan"
// cWrapperName: "casadi__SX__nan__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nan__3(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::SX::nan(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__nan__3(std::string ** err_msg, casadi::Sparsity* x0);
casadi::SX* casadi__SX__nan__3(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = casadi::SX::nan(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "numel" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::numel"
// cWrapperName: "casadi__SX__numel"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__numel(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->numel()"
// params: []
extern "C"
    int casadi__SX__numel(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__numel(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->numel();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nz_indexed" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed"
// cWrapperName: "casadi__SX__nz_indexed"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nz_indexed(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0)"
// call: "obj->nz_indexed(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__nz_indexed(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0);
casadi::SX* casadi__SX__nz_indexed(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);

        casadi::SX ret = obj->nz_indexed(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_assignment"
// cWrapperName: "casadi__SX__nz_indexed_assignment"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__nz_indexed_assignment(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__nz_indexed_assignment(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1);
void casadi__SX__nz_indexed_assignment(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_one_based"
// cWrapperName: "casadi__SX__nz_indexed_one_based__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nz_indexed_one_based__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__nz_indexed_one_based__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0);
casadi::SX* casadi__SX__nz_indexed_one_based__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::SX ret = obj->nz_indexed_one_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nz_indexed_one_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_one_based"
// cWrapperName: "casadi__SX__nz_indexed_one_based__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nz_indexed_one_based__1(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->nz_indexed_one_based(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__nz_indexed_one_based__1(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SX* casadi__SX__nz_indexed_one_based__1(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->nz_indexed_one_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__SX__nz_indexed_one_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1);
void casadi__SX__nz_indexed_one_based_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_one_based_assignment"
// cWrapperName: "casadi__SX__nz_indexed_one_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1);
void casadi__SX__nz_indexed_one_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_zero_based"
// cWrapperName: "casadi__SX__nz_indexed_zero_based__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nz_indexed_zero_based__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__nz_indexed_zero_based__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0);
casadi::SX* casadi__SX__nz_indexed_zero_based__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);

        casadi::SX ret = obj->nz_indexed_zero_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nz_indexed_zero_based" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_zero_based"
// cWrapperName: "casadi__SX__nz_indexed_zero_based__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__nz_indexed_zero_based__1(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->nz_indexed_zero_based(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__nz_indexed_zero_based__1(std::string ** err_msg, casadi::SX* obj, int x0);
casadi::SX* casadi__SX__nz_indexed_zero_based__1(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->nz_indexed_zero_based(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__SX__nz_indexed_zero_based_assignment__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1);
void casadi__SX__nz_indexed_zero_based_assignment__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::nz_indexed_zero_based_assignment"
// cWrapperName: "casadi__SX__nz_indexed_zero_based_assignment__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1);
void casadi__SX__nz_indexed_zero_based_assignment__1(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SXElement* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::ones"
// cWrapperName: "casadi__SX__ones__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__ones__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::SX::ones(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__ones__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::SX* casadi__SX__ones__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = casadi::SX::ones(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::ones"
// cWrapperName: "casadi__SX__ones__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__ones__1(std::string ** err_msg)"
// call: "casadi::SX::ones()"
// params: []
extern "C"
    casadi::SX* casadi__SX__ones__1(std::string ** err_msg);
casadi::SX* casadi__SX__ones__1(std::string ** err_msg){
    try {

        casadi::SX ret = casadi::SX::ones();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::ones"
// cWrapperName: "casadi__SX__ones__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__ones__2(std::string ** err_msg, int x0)"
// call: "casadi::SX::ones(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__ones__2(std::string ** err_msg, int x0);
casadi::SX* casadi__SX__ones__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = casadi::SX::ones(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "ones" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::ones"
// cWrapperName: "casadi__SX__ones__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__ones__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::SX::ones(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__ones__3(std::string ** err_msg, int x0, int x1);
casadi::SX* casadi__SX__ones__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = casadi::SX::ones(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "printDense" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::printDense"
// cWrapperName: "casadi__SX__printDense"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__printDense(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->printDense()"
// params: []
extern "C"
    void casadi__SX__printDense(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__printDense(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->printDense();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printScalar" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::printScalar"
// cWrapperName: "casadi__SX__printScalar"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__printScalar(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->printScalar()"
// params: []
extern "C"
    void casadi__SX__printScalar(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__printScalar(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->printScalar();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printSparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::printSparse"
// cWrapperName: "casadi__SX__printSparse"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__printSparse(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->printSparse()"
// params: []
extern "C"
    void casadi__SX__printSparse(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__printSparse(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->printSparse();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printVector" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::printVector"
// cWrapperName: "casadi__SX__printVector"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__printVector(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->printVector()"
// params: []
extern "C"
    void casadi__SX__printVector(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__printVector(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->printVector();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printme" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::printme"
// cWrapperName: "casadi__SX__printme"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->printme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX__printme(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->printme(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "quad_form" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::quad_form"
// cWrapperName: "casadi__SX__quad_form"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__quad_form(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1)"
// call: "casadi::SX::quad_form(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))))]
extern "C"
    casadi::SXElement* casadi__SX__quad_form(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1);
casadi::SXElement* casadi__SX__quad_form(std::string ** err_msg, casadi::SX* x0, std::vector< casadi::SXElement* >* x1){
    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);

        casadi::SXElement ret = casadi::SX::quad_form(x0_, x1_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "remove" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::remove"
// cWrapperName: "casadi__SX__remove"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->remove(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__SX__remove(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->remove(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::repmat"
// cWrapperName: "casadi__SX__repmat__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__repmat__0(std::string ** err_msg, casadi::SX* x0, int x1)"
// call: "casadi::SX::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt]
extern "C"
    casadi::SX* casadi__SX__repmat__0(std::string ** err_msg, casadi::SX* x0, int x1);
casadi::SX* casadi__SX__repmat__0(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::SX ret = casadi::SX::repmat(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::repmat"
// cWrapperName: "casadi__SX__repmat__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__repmat__1(std::string ** err_msg, casadi::SX* x0, int x1, int x2)"
// call: "casadi::SX::repmat(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__repmat__1(std::string ** err_msg, casadi::SX* x0, int x1, int x2);
casadi::SX* 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::SX::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;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::repmat"
// cWrapperName: "casadi__SX__repmat__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__repmat__2(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1)"
// call: "casadi::SX::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__repmat__2(std::string ** err_msg, casadi::SX* x0, casadi::Sparsity* x1);
casadi::SX* casadi__SX__repmat__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::SX::repmat(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "repmat" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::repmat"
// cWrapperName: "casadi__SX__repmat__3"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__repmat__3(std::string ** err_msg, casadi::SXElement* x0, casadi::Sparsity* x1)"
// call: "casadi::SX::repmat(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__repmat__3(std::string ** err_msg, casadi::SXElement* x0, casadi::Sparsity* x1);
casadi::SX* casadi__SX__repmat__3(std::string ** err_msg, casadi::SXElement* x0, casadi::Sparsity* x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::SX ret = casadi::SX::repmat(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "reserve" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::reserve"
// cWrapperName: "casadi__SX__reserve__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
void casadi__SX__reserve__0(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reserve" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::reserve"
// cWrapperName: "casadi__SX__reserve__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->reserve(x0_)"
// params: [CInt]
extern "C"
    void casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0);
void casadi__SX__reserve__1(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->reserve(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "resize" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::resize"
// cWrapperName: "casadi__SX__resize"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
void casadi__SX__resize(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "row" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::row"
// cWrapperName: "casadi__SX__row__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__row__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->row(x0_)"
// params: [CInt]
extern "C"
    int casadi__SX__row__0(std::string ** err_msg, casadi::SX* obj, int x0);
int casadi__SX__row__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        int ret = obj->row(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "row" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::row"
// cWrapperName: "casadi__SX__row__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__SX__row__1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->row()"
// params: []
extern "C"
    std::vector< int >* casadi__SX__row__1(std::string ** err_msg, casadi::SX* obj);
std::vector< int >* casadi__SX__row__1(std::string ** err_msg, casadi::SX* obj){
    try {

        std::vector< int > ret = obj->row();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sanityCheck"
// cWrapperName: "casadi__SX__sanityCheck__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__sanityCheck__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sanityCheck()"
// params: []
extern "C"
    void casadi__SX__sanityCheck__0(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__sanityCheck__0(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->sanityCheck();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sanityCheck"
// cWrapperName: "casadi__SX__sanityCheck__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__sanityCheck__1(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
// params: [CBool]
extern "C"
    void casadi__SX__sanityCheck__1(std::string ** err_msg, casadi::SX* obj, int x0);
void casadi__SX__sanityCheck__1(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "scalar_matrix" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::scalar_matrix"
// cWrapperName: "casadi__SX__scalar_matrix"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2)"
// call: "casadi::SX::scalar_matrix(x0_, x1_, x2_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2);
casadi::SX* casadi__SX__scalar_matrix(std::string ** err_msg, int x0, casadi::SX* x1, casadi::SX* x2){
    try {
        int x0_ = Marshaling<int,int>::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::SX::scalar_matrix(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::set"
// cWrapperName: "casadi__SX__set__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)"
// call: "obj->set(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
void casadi__SX__set__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::set"
// cWrapperName: "casadi__SX__set__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1);
void casadi__SX__set__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::set"
// cWrapperName: "casadi__SX__set__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0)"
// call: "obj->set(x0_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))))]
extern "C"
    void casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0);
void casadi__SX__set__2(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::set"
// cWrapperName: "casadi__SX__set__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1);
void casadi__SX__set__3(std::string ** err_msg, casadi::SX* obj, std::vector< casadi::SXElement* >* x0, int x1){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::set"
// cWrapperName: "casadi__SX__set__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// call: "obj->set(x0_)"
// params: [UserType (Namespace ["casadi"]) (Name "SXElement")]
extern "C"
    void casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0);
void casadi__SX__set__4(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

    obj->set(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "set" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::set"
// cWrapperName: "casadi__SX__set__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1)"
// call: "obj->set(x0_, x1_)"
// params: [UserType (Namespace ["casadi"]) (Name "SXElement"),CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    void casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1);
void casadi__SX__set__5(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0, int x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        casadi::SparsityType x1_ = Marshaling<casadi::SparsityType,int>::marshal(x1);

    obj->set(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setAll" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setAll"
// cWrapperName: "casadi__SX__setAll"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setAll(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0)"
// call: "obj->setAll(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__setAll(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0);
void casadi__SX__setAll(std::string ** err_msg, casadi::SX* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

    obj->setAll(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setEqualityCheckingDepth"
// cWrapperName: "casadi__SX__setEqualityCheckingDepth__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg)"
// call: "casadi::SX::setEqualityCheckingDepth()"
// params: []
extern "C"
    void casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg);
void casadi__SX__setEqualityCheckingDepth__0(std::string ** err_msg){
    try {

    casadi::SX::setEqualityCheckingDepth();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setEqualityCheckingDepth"
// cWrapperName: "casadi__SX__setEqualityCheckingDepth__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0)"
// call: "casadi::SX::setEqualityCheckingDepth(x0_)"
// params: [CInt]
extern "C"
    void casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0);
void casadi__SX__setEqualityCheckingDepth__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    casadi::SX::setEqualityCheckingDepth(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setMaxNumCallsInPrint"
// cWrapperName: "casadi__SX__setMaxNumCallsInPrint__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setMaxNumCallsInPrint__0(std::string ** err_msg)"
// call: "casadi::SX::setMaxNumCallsInPrint()"
// params: []
extern "C"
    void casadi__SX__setMaxNumCallsInPrint__0(std::string ** err_msg);
void casadi__SX__setMaxNumCallsInPrint__0(std::string ** err_msg){
    try {

    casadi::SX::setMaxNumCallsInPrint();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setMaxNumCallsInPrint"
// cWrapperName: "casadi__SX__setMaxNumCallsInPrint__1"
// protoArgs: "(std::string ** err_msg, long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0)"
// call: "casadi::SX::setMaxNumCallsInPrint(x0_)"
// params: [CLong]
extern "C"
    void casadi__SX__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0);
void casadi__SX__setMaxNumCallsInPrint__1(std::string ** err_msg, long x0){
    try {
        long x0_ = Marshaling<long,long>::marshal(x0);

    casadi::SX::setMaxNumCallsInPrint(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setNZ"
// cWrapperName: "casadi__SX__setNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__setNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1);
void casadi__SX__setNZ__0(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::SX* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setNZ"
// cWrapperName: "casadi__SX__setNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__setNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1);
void casadi__SX__setNZ__1(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::SX* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setNZ"
// cWrapperName: "casadi__SX__setNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::SX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__setNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::SX* x1);
void casadi__SX__setNZ__2(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::SX* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNZ" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setNZ"
// cWrapperName: "casadi__SX__setNZ__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setNZ__3(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SX* x1)"
// call: "obj->setNZ(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    void casadi__SX__setNZ__3(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SX* x1);
void casadi__SX__setNZ__3(std::string ** err_msg, casadi::SX* obj, int x0, casadi::SX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setPrecision" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setPrecision"
// cWrapperName: "casadi__SX__setPrecision"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setPrecision(std::string ** err_msg, int x0)"
// call: "casadi::SX::setPrecision(x0_)"
// params: [CInt]
extern "C"
    void casadi__SX__setPrecision(std::string ** err_msg, int x0);
void casadi__SX__setPrecision(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    casadi::SX::setPrecision(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setScientific" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setScientific"
// cWrapperName: "casadi__SX__setScientific"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setScientific(std::string ** err_msg, int x0)"
// call: "casadi::SX::setScientific(x0_)"
// params: [CBool]
extern "C"
    void casadi__SX__setScientific(std::string ** err_msg, int x0);
void casadi__SX__setScientific(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    casadi::SX::setScientific(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSparse"
// cWrapperName: "casadi__SX__setSparse__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__setSparse__0(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__setSparse__0(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0);
casadi::SX* casadi__SX__setSparse__0(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = obj->setSparse(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setSparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSparse"
// cWrapperName: "casadi__SX__setSparse__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__setSparse__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool]
extern "C"
    casadi::SX* casadi__SX__setSparse__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1);
casadi::SX* casadi__SX__setSparse__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::SX ret = obj->setSparse(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    void casadi__SX__setSub__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1, int x2);
void casadi__SX__setSub__0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Sparsity* x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Const CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__SX__setSub__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2);
void casadi__SX__setSub__1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::Slice* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    void casadi__SX__setSub__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, int x2);
void casadi__SX__setSub__2(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__SX__setSub__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__SX__setSub__3(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::IMatrix* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__SX__setSub__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::IMatrix* x2);
void casadi__SX__setSub__4(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::IMatrix* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__SX__setSub__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::Slice* x2);
void casadi__SX__setSub__5(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, casadi::Slice* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__6"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__SX__setSub__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2);
void casadi__SX__setSub__6(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, casadi::IMatrix* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__7"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__7(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::IMatrix* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    void casadi__SX__setSub__7(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::IMatrix* x2);
void casadi__SX__setSub__7(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::IMatrix* 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);
        casadi::IMatrix x2_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__8"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__8(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    void casadi__SX__setSub__8(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, int x2);
void casadi__SX__setSub__8(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, int x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__9"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__9(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__setSub__9(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, std::vector< int >* x2);
void casadi__SX__setSub__9(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::IMatrix* x1, std::vector< int >* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__10"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__10(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__SX__setSub__10(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::Slice* x2);
void casadi__SX__setSub__10(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, casadi::Slice* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__11"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__11(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    void casadi__SX__setSub__11(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::Slice* x2);
void casadi__SX__setSub__11(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, casadi::Slice* 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);
        casadi::Slice x2_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__12"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__12(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__setSub__12(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, std::vector< int >* x2);
void casadi__SX__setSub__12(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, casadi::Slice* x1, std::vector< int >* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__13"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__13(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__setSub__13(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, std::vector< int >* x2);
void casadi__SX__setSub__13(std::string ** err_msg, casadi::SX* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__14"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__14(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,Ref (Const (StdVec CInt))]
extern "C"
    void casadi__SX__setSub__14(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, std::vector< int >* x2);
void casadi__SX__setSub__14(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, std::vector< int >* x2){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__15"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__15(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (StdVec CInt)),CInt]
extern "C"
    void casadi__SX__setSub__15(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, int x2);
void casadi__SX__setSub__15(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, std::vector< int >* x1, 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);
        int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setSub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setSub"
// cWrapperName: "casadi__SX__setSub__16"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setSub__16(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CInt,CInt]
extern "C"
    void casadi__SX__setSub__16(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0, int x1, int x2);
void casadi__SX__setSub__16(std::string ** err_msg, casadi::SX* obj, 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);

    obj->setSub(x0_, x1_, x2_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "setWidth" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setWidth"
// cWrapperName: "casadi__SX__setWidth"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setWidth(std::string ** err_msg, int x0)"
// call: "casadi::SX::setWidth(x0_)"
// params: [CInt]
extern "C"
    void casadi__SX__setWidth(std::string ** err_msg, int x0);
void casadi__SX__setWidth(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    casadi::SX::setWidth(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setZero" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::setZero"
// cWrapperName: "casadi__SX__setZero"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__setZero(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->setZero()"
// params: []
extern "C"
    void casadi__SX__setZero(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__setZero(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->setZero();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sign" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sign"
// cWrapperName: "casadi__SX__sign"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sign(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sign()"
// params: []
extern "C"
    casadi::SX* casadi__SX__sign(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__sign(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->sign();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sin" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sin"
// cWrapperName: "casadi__SX__sin"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sin(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sin()"
// params: []
extern "C"
    casadi::SX* casadi__SX__sin(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__sin(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->sin();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sinh" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sinh"
// cWrapperName: "casadi__SX__sinh"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sinh(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sinh()"
// params: []
extern "C"
    casadi::SX* casadi__SX__sinh(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__sinh(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->sinh();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::size"
// cWrapperName: "casadi__SX__size__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__size__0(std::string ** err_msg, casadi::SX* obj, int x0)"
// call: "obj->size(x0_)"
// params: [CEnum (Namespace ["casadi"]) (Name "SparsityType")]
extern "C"
    int casadi__SX__size__0(std::string ** err_msg, casadi::SX* obj, int x0);
int casadi__SX__size__0(std::string ** err_msg, casadi::SX* obj, int x0){
    try {
        casadi::SparsityType x0_ = Marshaling<casadi::SparsityType,int>::marshal(x0);

        int ret = obj->size(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::size"
// cWrapperName: "casadi__SX__size__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__size__1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->size()"
// params: []
extern "C"
    int casadi__SX__size__1(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__size__1(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->size();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size1" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::size1"
// cWrapperName: "casadi__SX__size1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__size1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->size1()"
// params: []
extern "C"
    int casadi__SX__size1(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__size1(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->size1();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size2" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::size2"
// cWrapperName: "casadi__SX__size2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__size2(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->size2()"
// params: []
extern "C"
    int casadi__SX__size2(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__size2(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->size2();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sizeD" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sizeD"
// cWrapperName: "casadi__SX__sizeD"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__sizeD(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sizeD()"
// params: []
extern "C"
    int casadi__SX__sizeD(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__sizeD(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->sizeD();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sizeL" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sizeL"
// cWrapperName: "casadi__SX__sizeL"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__sizeL(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sizeL()"
// params: []
extern "C"
    int casadi__SX__sizeL(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__sizeL(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->sizeL();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sizeU" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sizeU"
// cWrapperName: "casadi__SX__sizeU"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SX__sizeU(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sizeU()"
// params: []
extern "C"
    int casadi__SX__sizeU(std::string ** err_msg, casadi::SX* obj);
int casadi__SX__sizeU(std::string ** err_msg, casadi::SX* obj){
    try {

        int ret = obj->sizeU();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparse"
// cWrapperName: "casadi__SX__sparse__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sparse__0(std::string ** err_msg)"
// call: "casadi::SX::sparse()"
// params: []
extern "C"
    casadi::SX* casadi__SX__sparse__0(std::string ** err_msg);
casadi::SX* casadi__SX__sparse__0(std::string ** err_msg){
    try {

        casadi::SX ret = casadi::SX::sparse();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparse"
// cWrapperName: "casadi__SX__sparse__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sparse__1(std::string ** err_msg, int x0)"
// call: "casadi::SX::sparse(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__sparse__1(std::string ** err_msg, int x0);
casadi::SX* casadi__SX__sparse__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = casadi::SX::sparse(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sparse" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparse"
// cWrapperName: "casadi__SX__sparse__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sparse__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::SX::sparse(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__sparse__2(std::string ** err_msg, int x0, int x1);
casadi::SX* casadi__SX__sparse__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = casadi::SX::sparse(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sparsify" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparsify"
// cWrapperName: "casadi__SX__sparsify__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__sparsify__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sparsify()"
// params: []
extern "C"
    void casadi__SX__sparsify__0(std::string ** err_msg, casadi::SX* obj);
void casadi__SX__sparsify__0(std::string ** err_msg, casadi::SX* obj){
    try {

    obj->sparsify();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sparsify" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparsify"
// cWrapperName: "casadi__SX__sparsify__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SX__sparsify__1(std::string ** err_msg, casadi::SX* obj, double x0)"
// call: "obj->sparsify(x0_)"
// params: [CDouble]
extern "C"
    void casadi__SX__sparsify__1(std::string ** err_msg, casadi::SX* obj, double x0);
void casadi__SX__sparsify__1(std::string ** err_msg, casadi::SX* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->sparsify(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sparsity" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparsity"
// cWrapperName: "casadi__SX__sparsity__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__SX__sparsity__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__SX__sparsity__0(std::string ** err_msg, casadi::SX* obj);
casadi::Sparsity* casadi__SX__sparsity__0(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::Sparsity ret = obj->sparsity();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sparsity" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparsity"
// cWrapperName: "casadi__SX__sparsity__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__SX__sparsity__1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__SX__sparsity__1(std::string ** err_msg, casadi::SX* obj);
casadi::Sparsity* casadi__SX__sparsity__1(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::Sparsity ret = obj->sparsity();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparsityRef"
// cWrapperName: "casadi__SX__sparsityRef__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__SX__sparsityRef__0(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__SX__sparsityRef__0(std::string ** err_msg, casadi::SX* obj);
casadi::Sparsity* casadi__SX__sparsityRef__0(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::Sparsity ret = obj->sparsityRef();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sparsityRef" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sparsityRef"
// cWrapperName: "casadi__SX__sparsityRef__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__SX__sparsityRef__1(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sparsityRef()"
// params: []
extern "C"
    casadi::Sparsity* casadi__SX__sparsityRef__1(std::string ** err_msg, casadi::SX* obj);
casadi::Sparsity* casadi__SX__sparsityRef__1(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::Sparsity ret = obj->sparsityRef();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sqrt" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sqrt"
// cWrapperName: "casadi__SX__sqrt"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sqrt(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->sqrt()"
// params: []
extern "C"
    casadi::SX* casadi__SX__sqrt(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__sqrt(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->sqrt();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__0"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__0(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0)"
// call: "obj->sub(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__sub__0(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0);
casadi::SX* casadi__SX__sub__0(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = obj->sub(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__1"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::SX* casadi__SX__sub__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1);
casadi::SX* casadi__SX__sub__1(std::string ** err_msg, casadi::SX* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__2"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__sub__2(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::IMatrix* x1);
casadi::SX* casadi__SX__sub__2(std::string ** err_msg, casadi::SX* obj, 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::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__3"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__3(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__sub__3(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1);
casadi::SX* casadi__SX__sub__3(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::IMatrix* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__4"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__4(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__sub__4(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1);
casadi::SX* casadi__SX__sub__4(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, casadi::Slice* x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__5"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__5(std::string ** err_msg, casadi::SX* obj, int x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__sub__5(std::string ** err_msg, casadi::SX* obj, int x0, casadi::IMatrix* x1);
casadi::SX* casadi__SX__sub__5(std::string ** err_msg, casadi::SX* obj, int x0, casadi::IMatrix* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__6"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__6(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::IMatrix* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    casadi::SX* casadi__SX__sub__6(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::IMatrix* x1);
casadi::SX* casadi__SX__sub__6(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::IMatrix* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::IMatrix x1_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__7"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__7(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),CInt]
extern "C"
    casadi::SX* casadi__SX__sub__7(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, int x1);
casadi::SX* casadi__SX__sub__7(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, int x1){
    try {
        casadi::IMatrix x0_ = Marshaling<casadi::IMatrix,casadi::IMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__8"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__8(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::SX* casadi__SX__sub__8(std::string ** err_msg, casadi::SX* obj, casadi::IMatrix* x0, std::vector< int >* x1);
casadi::SX* casadi__SX__sub__8(std::string ** err_msg, casadi::SX* obj, 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);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__9"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__9(std::string ** err_msg, casadi::SX* obj, int x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__sub__9(std::string ** err_msg, casadi::SX* obj, int x0, casadi::Slice* x1);
casadi::SX* casadi__SX__sub__9(std::string ** err_msg, casadi::SX* obj, int x0, casadi::Slice* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__10"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__10(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    casadi::SX* casadi__SX__sub__10(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, int x1);
casadi::SX* casadi__SX__sub__10(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, int x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__11"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__11(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__sub__11(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1);
casadi::SX* casadi__SX__sub__11(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, casadi::Slice* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__12"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__12(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::Slice* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice")))]
extern "C"
    casadi::SX* casadi__SX__sub__12(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::Slice* x1);
casadi::SX* casadi__SX__sub__12(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, casadi::Slice* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__13"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__13(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),Ref (Const (StdVec CInt))]
extern "C"
    casadi::SX* casadi__SX__sub__13(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, std::vector< int >* x1);
casadi::SX* casadi__SX__sub__13(std::string ** err_msg, casadi::SX* obj, casadi::Slice* x0, std::vector< int >* x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__14"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__14(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::SX* casadi__SX__sub__14(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1);
casadi::SX* casadi__SX__sub__14(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__15"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__15(std::string ** err_msg, casadi::SX* obj, int x0, std::vector< int >* x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,Ref (Const (StdVec CInt))]
extern "C"
    casadi::SX* casadi__SX__sub__15(std::string ** err_msg, casadi::SX* obj, int x0, std::vector< int >* x1);
casadi::SX* casadi__SX__sub__15(std::string ** err_msg, casadi::SX* obj, int x0, std::vector< int >* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__16"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__16(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),CInt]
extern "C"
    casadi::SX* casadi__SX__sub__16(std::string ** err_msg, casadi::SX* obj, std::vector< int >* x0, int x1);
casadi::SX* casadi__SX__sub__16(std::string ** err_msg, casadi::SX* obj, 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);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sub"
// cWrapperName: "casadi__SX__sub__17"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sub__17(std::string ** err_msg, casadi::SX* obj, int x0, int x1)"
// call: "obj->sub(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__sub__17(std::string ** err_msg, casadi::SX* obj, int x0, int x1);
casadi::SX* casadi__SX__sub__17(std::string ** err_msg, casadi::SX* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->sub(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
// proto: "std::vector< std::vector< casadi::SX* >* >* casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4)"
// call: "casadi::SX::sym(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const StdString),CInt,CInt,CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::SX* >* >* casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< casadi::SX* >* >* casadi__SX__sym__0(std::string ** err_msg, std::string* x0, int x1, int x2, int x3, int x4){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_, x4_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__1"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// cWrapperRetType: "std::vector< std::vector< casadi::SX* >* >*"
// proto: "std::vector< std::vector< casadi::SX* >* >* casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3)"
// call: "casadi::SX::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt,CInt]
extern "C"
    std::vector< std::vector< casadi::SX* >* >* casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< casadi::SX* >* >* casadi__SX__sym__1(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< std::vector< casadi::SX > > ret = casadi::SX::sym(x0_, x1_, x2_, x3_);
        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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__2"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3)"
// call: "casadi::SX::sym(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CInt,CInt]
extern "C"
    std::vector< casadi::SX* >* casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3);
std::vector< casadi::SX* >* casadi__SX__sym__2(std::string ** err_msg, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        std::vector< casadi::SX > ret = casadi::SX::sym(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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__3"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2)"
// call: "casadi::SX::sym(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    std::vector< casadi::SX* >* casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2);
std::vector< casadi::SX* >* casadi__SX__sym__3(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        std::vector< casadi::SX > ret = casadi::SX::sym(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;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__4"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// call: "casadi::SX::sym(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
casadi::SX* casadi__SX__sym__4(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Sparsity x1_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x1);

        casadi::SX ret = casadi::SX::sym(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__5"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sym__5(std::string ** err_msg, std::string* x0)"
// call: "casadi::SX::sym(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SX__sym__5(std::string ** err_msg, std::string* x0);
casadi::SX* casadi__SX__sym__5(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = casadi::SX::sym(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__6"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sym__6(std::string ** err_msg, std::string* x0, int x1)"
// call: "casadi::SX::sym(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::SX* casadi__SX__sym__6(std::string ** err_msg, std::string* x0, int x1);
casadi::SX* casadi__SX__sym__6(std::string ** err_msg, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = casadi::SX::sym(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::sym"
// cWrapperName: "casadi__SX__sym__7"
// protoArgs: "(std::string ** err_msg, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1, int x2)"
// call: "casadi::SX::sym(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1, int x2);
casadi::SX* casadi__SX__sym__7(std::string ** err_msg, std::string* x0, int x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::SX ret = casadi::SX::sym(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tan" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::tan"
// cWrapperName: "casadi__SX__tan"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__tan(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->tan()"
// params: []
extern "C"
    casadi::SX* casadi__SX__tan(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__tan(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->tan();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tanh" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::tanh"
// cWrapperName: "casadi__SX__tanh"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__tanh(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->tanh()"
// params: []
extern "C"
    casadi::SX* casadi__SX__tanh(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__tanh(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->tanh();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "toScalar" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::toScalar"
// cWrapperName: "casadi__SX__toScalar"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SXElement"))
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__toScalar(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->toScalar()"
// params: []
extern "C"
    casadi::SXElement* casadi__SX__toScalar(std::string ** err_msg, casadi::SX* obj);
casadi::SXElement* casadi__SX__toScalar(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SXElement ret = obj->toScalar();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "trans" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::trans"
// cWrapperName: "casadi__SX__trans"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__trans(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->trans()"
// params: []
extern "C"
    casadi::SX* casadi__SX__trans(std::string ** err_msg, casadi::SX* obj);
casadi::SX* casadi__SX__trans(std::string ** err_msg, casadi::SX* obj){
    try {

        casadi::SX ret = obj->trans();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "triplet" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::triplet"
// cWrapperName: "casadi__SX__triplet__0"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2, int x3, int x4)"
// call: "casadi::SX::triplet(x0_, x1_, x2_, x3_, x4_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2, int x3, int x4);
casadi::SX* casadi__SX__triplet__0(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2, int x3, int x4){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);
        int x4_ = Marshaling<int,int>::marshal(x4);

        casadi::SX ret = casadi::SX::triplet(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;
    }
}


// ================== Static method: "triplet" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::triplet"
// cWrapperName: "casadi__SX__triplet__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2)"
// call: "casadi::SX::triplet(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))))]
extern "C"
    casadi::SX* casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2);
casadi::SX* casadi__SX__triplet__1(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, std::vector< casadi::SXElement* >* x2){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        std::vector< casadi::SXElement > x2_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x2);

        casadi::SX ret = casadi::SX::triplet(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "unary" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::unary"
// cWrapperName: "casadi__SX__unary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1)"
// call: "casadi::SX::unary(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1);
casadi::SX* casadi__SX__unary(std::string ** err_msg, int x0, casadi::SX* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);

        casadi::SX ret = casadi::SX::unary(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::zeros"
// cWrapperName: "casadi__SX__zeros__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__zeros__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::SX::zeros(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SX* casadi__SX__zeros__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::SX* casadi__SX__zeros__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SX ret = casadi::SX::zeros(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::zeros"
// cWrapperName: "casadi__SX__zeros__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__zeros__1(std::string ** err_msg)"
// call: "casadi::SX::zeros()"
// params: []
extern "C"
    casadi::SX* casadi__SX__zeros__1(std::string ** err_msg);
casadi::SX* casadi__SX__zeros__1(std::string ** err_msg){
    try {

        casadi::SX ret = casadi::SX::zeros();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::zeros"
// cWrapperName: "casadi__SX__zeros__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__zeros__2(std::string ** err_msg, int x0)"
// call: "casadi::SX::zeros(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SX__zeros__2(std::string ** err_msg, int x0);
casadi::SX* casadi__SX__zeros__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = casadi::SX::zeros(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "zeros" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::zeros"
// cWrapperName: "casadi__SX__zeros__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SX__zeros__3(std::string ** err_msg, int x0, int x1)"
// call: "casadi::SX::zeros(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SX__zeros__3(std::string ** err_msg, int x0, int x1);
casadi::SX* casadi__SX__zeros__3(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = casadi::SX::zeros(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SXElement")===============
// classType: UserType (Namespace ["casadi"]) (Name "SXElement")
extern "C"
    void delete_casadi__SXElement(casadi::SXElement* obj);
void delete_casadi__SXElement(casadi::SXElement* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement"
// cWrapperName: "casadi__SXElement__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__CONSTRUCTOR__0(std::string ** err_msg, double x0)"
// call: "casadi::SXElement(x0_)"
// params: [CDouble]
extern "C"
    casadi::SXElement* casadi__SXElement__CONSTRUCTOR__0(std::string ** err_msg, double x0);
casadi::SXElement* casadi__SXElement__CONSTRUCTOR__0(std::string ** err_msg, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

        casadi::SXElement ret = casadi::SXElement(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement"
// cWrapperName: "casadi__SXElement__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__CONSTRUCTOR__1(std::string ** err_msg)"
// call: "casadi::SXElement()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__CONSTRUCTOR__1(std::string ** err_msg);
casadi::SXElement* casadi__SXElement__CONSTRUCTOR__1(std::string ** err_msg){
    try {

        casadi::SXElement ret = casadi::SXElement();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__add__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__add__"
// cWrapperName: "casadi__SXElement____add__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____add__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__add__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____add__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____add__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__add__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__constpow__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__constpow__"
// cWrapperName: "casadi__SXElement____constpow__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____constpow__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__constpow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____constpow__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____constpow__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__constpow__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__copysign__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__copysign__"
// cWrapperName: "casadi__SXElement____copysign____0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXElement____copysign____0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// call: "obj->__copysign__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SXElement____copysign____0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0);
casadi::SX* casadi__SXElement____copysign____0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->__copysign__(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__copysign__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__copysign__"
// cWrapperName: "casadi__SXElement____copysign____1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____copysign____1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__copysign__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____copysign____1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____copysign____1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__copysign__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__div__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__div__"
// cWrapperName: "casadi__SXElement____div__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____div__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__div__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____div__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____div__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__div__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__eq__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__eq__"
// cWrapperName: "casadi__SXElement____eq__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____eq__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__eq__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____eq__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____eq__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__eq__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__ge__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__ge__"
// cWrapperName: "casadi__SXElement____ge__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____ge__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__ge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____ge__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____ge__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__ge__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__gt__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__gt__"
// cWrapperName: "casadi__SXElement____gt__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____gt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__gt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____gt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____gt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__gt__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__hash__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__hash__"
// cWrapperName: "casadi__SXElement____hash__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long casadi__SXElement____hash__(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->__hash__()"
// params: []
extern "C"
    long casadi__SXElement____hash__(std::string ** err_msg, casadi::SXElement* obj);
long casadi__SXElement____hash__(std::string ** err_msg, casadi::SXElement* obj){
    try {

        long ret = obj->__hash__();
        return WrapReturn< long, long >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__le__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__le__"
// cWrapperName: "casadi__SXElement____le__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____le__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__le__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____le__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____le__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__le__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__lt__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__lt__"
// cWrapperName: "casadi__SXElement____lt__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____lt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__lt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____lt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____lt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__lt__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mldivide__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__mldivide__"
// cWrapperName: "casadi__SXElement____mldivide__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____mldivide__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__mldivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____mldivide__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____mldivide__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__mldivide__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mpower__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__mpower__"
// cWrapperName: "casadi__SXElement____mpower__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____mpower__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__mpower__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____mpower__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____mpower__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__mpower__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mrdivide__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__mrdivide__"
// cWrapperName: "casadi__SXElement____mrdivide__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____mrdivide__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__mrdivide__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____mrdivide__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____mrdivide__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__mrdivide__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__mul__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__mul__"
// cWrapperName: "casadi__SXElement____mul__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____mul__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__mul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____mul__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____mul__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__mul__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__ne__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__ne__"
// cWrapperName: "casadi__SXElement____ne__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____ne__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__ne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____ne__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____ne__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__ne__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__nonzero__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__nonzero__"
// cWrapperName: "casadi__SXElement____nonzero__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement____nonzero__(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->__nonzero__()"
// params: []
extern "C"
    int casadi__SXElement____nonzero__(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement____nonzero__(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->__nonzero__();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__pow__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__pow__"
// cWrapperName: "casadi__SXElement____pow__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____pow__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__pow__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____pow__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____pow__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__pow__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__radd__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__radd__"
// cWrapperName: "casadi__SXElement____radd__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____radd__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__radd__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____radd__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____radd__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__radd__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rdiv__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rdiv__"
// cWrapperName: "casadi__SXElement____rdiv__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rdiv__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rdiv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rdiv__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rdiv__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rdiv__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__req__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__req__"
// cWrapperName: "casadi__SXElement____req__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____req__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__req__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____req__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____req__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__req__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rge__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rge__"
// cWrapperName: "casadi__SXElement____rge__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rge__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rge__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rge__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rge__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rge__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rgt__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rgt__"
// cWrapperName: "casadi__SXElement____rgt__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rgt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rgt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rgt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rgt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rgt__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rle__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rle__"
// cWrapperName: "casadi__SXElement____rle__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rle__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rle__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rle__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rle__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rle__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rlt__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rlt__"
// cWrapperName: "casadi__SXElement____rlt__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rlt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rlt__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rlt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rlt__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rlt__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rmul__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rmul__"
// cWrapperName: "casadi__SXElement____rmul__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rmul__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rmul__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rmul__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rmul__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rmul__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rne__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rne__"
// cWrapperName: "casadi__SXElement____rne__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rne__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rne__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rne__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rne__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rne__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rsub__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rsub__"
// cWrapperName: "casadi__SXElement____rsub__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rsub__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rsub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rsub__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rsub__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rsub__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__rtruediv__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__rtruediv__"
// cWrapperName: "casadi__SXElement____rtruediv__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____rtruediv__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__rtruediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____rtruediv__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____rtruediv__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__rtruediv__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__sub__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__sub__"
// cWrapperName: "casadi__SXElement____sub__"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____sub__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__sub__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____sub__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____sub__(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__sub__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__truediv__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__truediv__"
// cWrapperName: "casadi__SXElement____truediv____0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____truediv____0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____truediv____0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____truediv____0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__truediv__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "__truediv__" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::__truediv__"
// cWrapperName: "casadi__SXElement____truediv____1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement____truediv____1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->__truediv__(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement____truediv____1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement____truediv____1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->__truediv__(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arccos" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arccos"
// cWrapperName: "casadi__SXElement__arccos"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arccos(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->arccos()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__arccos(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__arccos(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->arccos();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arccosh" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arccosh"
// cWrapperName: "casadi__SXElement__arccosh"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arccosh(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->arccosh()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__arccosh(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__arccosh(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->arccosh();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arcsin" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arcsin"
// cWrapperName: "casadi__SXElement__arcsin"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arcsin(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->arcsin()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__arcsin(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__arcsin(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->arcsin();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arcsinh" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arcsinh"
// cWrapperName: "casadi__SXElement__arcsinh"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arcsinh(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->arcsinh()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__arcsinh(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__arcsinh(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->arcsinh();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctan" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arctan"
// cWrapperName: "casadi__SXElement__arctan"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arctan(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->arctan()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__arctan(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__arctan(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->arctan();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctan2" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arctan2"
// cWrapperName: "casadi__SXElement__arctan2__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXElement__arctan2__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// call: "obj->arctan2(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SXElement__arctan2__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0);
casadi::SX* casadi__SXElement__arctan2__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->arctan2(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctan2" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arctan2"
// cWrapperName: "casadi__SXElement__arctan2__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arctan2__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->arctan2(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__arctan2__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__arctan2__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->arctan2(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "arctanh" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::arctanh"
// cWrapperName: "casadi__SXElement__arctanh"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__arctanh(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->arctanh()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__arctanh(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__arctanh(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->arctanh();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "assignIfDuplicate" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::assignIfDuplicate"
// cWrapperName: "casadi__SXElement__assignIfDuplicate__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SXElement__assignIfDuplicate__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->assignIfDuplicate(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SXElement__assignIfDuplicate__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
void casadi__SXElement__assignIfDuplicate__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

    obj->assignIfDuplicate(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "assignIfDuplicate" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::assignIfDuplicate"
// cWrapperName: "casadi__SXElement__assignIfDuplicate__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SXElement__assignIfDuplicate__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1)"
// call: "obj->assignIfDuplicate(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),CInt]
extern "C"
    void casadi__SXElement__assignIfDuplicate__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1);
void casadi__SXElement__assignIfDuplicate__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->assignIfDuplicate(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "binary" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::binary"
// cWrapperName: "casadi__SXElement__binary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SXElement* x1, casadi::SXElement* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__binary(std::string ** err_msg, int x0, casadi::SXElement* x1, casadi::SXElement* x2)"
// call: "casadi::SXElement::binary(x0_, x1_, x2_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__binary(std::string ** err_msg, int x0, casadi::SXElement* x1, casadi::SXElement* x2);
casadi::SXElement* casadi__SXElement__binary(std::string ** err_msg, int x0, casadi::SXElement* x1, casadi::SXElement* x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);
        casadi::SXElement x2_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x2);

        casadi::SXElement ret = casadi::SXElement::binary(x0_, x1_, x2_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "ceil" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::ceil"
// cWrapperName: "casadi__SXElement__ceil"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__ceil(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->ceil()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__ceil(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__ceil(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->ceil();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "constpow" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::constpow"
// cWrapperName: "casadi__SXElement__constpow__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXElement__constpow__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// call: "obj->constpow(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SXElement__constpow__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0);
casadi::SX* casadi__SXElement__constpow__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->constpow(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "constpow" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::constpow"
// cWrapperName: "casadi__SXElement__constpow__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__constpow__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->constpow(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__constpow__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__constpow__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->constpow(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "cos" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::cos"
// cWrapperName: "casadi__SXElement__cos"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__cos(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->cos()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__cos(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__cos(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->cos();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "cosh" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::cosh"
// cWrapperName: "casadi__SXElement__cosh"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__cosh(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->cosh()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__cosh(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__cosh(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->cosh();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "erf" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::erf"
// cWrapperName: "casadi__SXElement__erf"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__erf(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->erf()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__erf(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__erf(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->erf();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "erfinv" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::erfinv"
// cWrapperName: "casadi__SXElement__erfinv"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__erfinv(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->erfinv()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__erfinv(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__erfinv(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->erfinv();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "exp" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::exp"
// cWrapperName: "casadi__SXElement__exp"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__exp(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->exp()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__exp(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__exp(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->exp();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fabs" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::fabs"
// cWrapperName: "casadi__SXElement__fabs"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__fabs(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->fabs()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__fabs(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__fabs(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->fabs();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "floor" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::floor"
// cWrapperName: "casadi__SXElement__floor"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__floor(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->floor()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__floor(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__floor(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->floor();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmax" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::fmax"
// cWrapperName: "casadi__SXElement__fmax__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXElement__fmax__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// call: "obj->fmax(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SXElement__fmax__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0);
casadi::SX* casadi__SXElement__fmax__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->fmax(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmax" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::fmax"
// cWrapperName: "casadi__SXElement__fmax__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__fmax__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->fmax(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__fmax__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__fmax__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->fmax(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmin" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::fmin"
// cWrapperName: "casadi__SXElement__fmin__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXElement__fmin__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0)"
// call: "obj->fmin(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SXElement__fmin__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0);
casadi::SX* casadi__SXElement__fmin__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

        casadi::SX ret = obj->fmin(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmin" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::fmin"
// cWrapperName: "casadi__SXElement__fmin__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__fmin__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->fmin(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__fmin__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__fmin__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->fmin(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "fmod" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::fmod"
// cWrapperName: "casadi__SXElement__fmod"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__fmod(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->fmod(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__fmod(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__fmod(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->fmod(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getDep" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getDep"
// cWrapperName: "casadi__SXElement__getDep__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__getDep__0(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getDep()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__getDep__0(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__getDep__0(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->getDep();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getDep" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getDep"
// cWrapperName: "casadi__SXElement__getDep__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__getDep__1(std::string ** err_msg, casadi::SXElement* obj, int x0)"
// call: "obj->getDep(x0_)"
// params: [CInt]
extern "C"
    casadi::SXElement* casadi__SXElement__getDep__1(std::string ** err_msg, casadi::SXElement* obj, int x0);
casadi::SXElement* casadi__SXElement__getDep__1(std::string ** err_msg, casadi::SXElement* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SXElement ret = obj->getDep(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getIntValue" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getIntValue"
// cWrapperName: "casadi__SXElement__getIntValue"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__getIntValue(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getIntValue()"
// params: []
extern "C"
    int casadi__SXElement__getIntValue(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__getIntValue(std::string ** err_msg, casadi::SXElement* obj){
    try {

        int ret = obj->getIntValue();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getName" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getName"
// cWrapperName: "casadi__SXElement__getName"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: Const StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SXElement__getName(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getName()"
// params: []
extern "C"
    std::string* casadi__SXElement__getName(std::string ** err_msg, casadi::SXElement* obj);
std::string* casadi__SXElement__getName(std::string ** err_msg, casadi::SXElement* obj){
    try {

        std::string ret = obj->getName();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNdeps" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getNdeps"
// cWrapperName: "casadi__SXElement__getNdeps"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__getNdeps(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getNdeps()"
// params: []
extern "C"
    int casadi__SXElement__getNdeps(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__getNdeps(std::string ** err_msg, casadi::SXElement* obj){
    try {

        int ret = obj->getNdeps();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOp" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getOp"
// cWrapperName: "casadi__SXElement__getOp"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__getOp(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getOp()"
// params: []
extern "C"
    int casadi__SXElement__getOp(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__getOp(std::string ** err_msg, casadi::SXElement* obj){
    try {

        int ret = obj->getOp();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getTemp" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getTemp"
// cWrapperName: "casadi__SXElement__getTemp"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__getTemp(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getTemp()"
// params: []
extern "C"
    int casadi__SXElement__getTemp(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__getTemp(std::string ** err_msg, casadi::SXElement* obj){
    try {

        int ret = obj->getTemp();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getValue" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getValue"
// cWrapperName: "casadi__SXElement__getValue"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__SXElement__getValue(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getValue()"
// params: []
extern "C"
    double casadi__SXElement__getValue(std::string ** err_msg, casadi::SXElement* obj);
double casadi__SXElement__getValue(std::string ** err_msg, casadi::SXElement* obj){
    try {

        double ret = obj->getValue();
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hasDep" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::hasDep"
// cWrapperName: "casadi__SXElement__hasDep"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__hasDep(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->hasDep()"
// params: []
extern "C"
    int casadi__SXElement__hasDep(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__hasDep(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->hasDep();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "if_else_zero" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::if_else_zero"
// cWrapperName: "casadi__SXElement__if_else_zero"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__if_else_zero(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->if_else_zero(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__if_else_zero(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__if_else_zero(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->if_else_zero(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "inv" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::inv"
// cWrapperName: "casadi__SXElement__inv"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__inv(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->inv()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__inv(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__inv(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->inv();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isAlmostZero" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isAlmostZero"
// cWrapperName: "casadi__SXElement__isAlmostZero"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, double x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isAlmostZero(std::string ** err_msg, casadi::SXElement* obj, double x0)"
// call: "obj->isAlmostZero(x0_)"
// params: [CDouble]
extern "C"
    int casadi__SXElement__isAlmostZero(std::string ** err_msg, casadi::SXElement* obj, double x0);
int casadi__SXElement__isAlmostZero(std::string ** err_msg, casadi::SXElement* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

        bool ret = obj->isAlmostZero(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isCommutative" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isCommutative"
// cWrapperName: "casadi__SXElement__isCommutative"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isCommutative(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isCommutative()"
// params: []
extern "C"
    int casadi__SXElement__isCommutative(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isCommutative(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isCommutative();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isConstant" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isConstant"
// cWrapperName: "casadi__SXElement__isConstant"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isConstant(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isConstant()"
// params: []
extern "C"
    int casadi__SXElement__isConstant(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isConstant(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isConstant();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isDoubled" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isDoubled"
// cWrapperName: "casadi__SXElement__isDoubled"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isDoubled(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isDoubled()"
// params: []
extern "C"
    int casadi__SXElement__isDoubled(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isDoubled(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isDoubled();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEqual" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isEqual"
// cWrapperName: "casadi__SXElement__isEqual__0"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isEqual__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->isEqual(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    int casadi__SXElement__isEqual__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
int casadi__SXElement__isEqual__0(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        bool ret = obj->isEqual(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEqual" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isEqual"
// cWrapperName: "casadi__SXElement__isEqual__1"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isEqual__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1)"
// call: "obj->isEqual(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement"))),CInt]
extern "C"
    int casadi__SXElement__isEqual__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1);
int casadi__SXElement__isEqual__1(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0, int x1){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        bool ret = obj->isEqual(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isInf" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isInf"
// cWrapperName: "casadi__SXElement__isInf"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isInf(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isInf()"
// params: []
extern "C"
    int casadi__SXElement__isInf(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isInf(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isInf();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isInteger" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isInteger"
// cWrapperName: "casadi__SXElement__isInteger"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isInteger(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isInteger()"
// params: []
extern "C"
    int casadi__SXElement__isInteger(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isInteger(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isInteger();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isLeaf" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isLeaf"
// cWrapperName: "casadi__SXElement__isLeaf"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isLeaf(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isLeaf()"
// params: []
extern "C"
    int casadi__SXElement__isLeaf(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isLeaf(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isLeaf();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isMinusInf" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isMinusInf"
// cWrapperName: "casadi__SXElement__isMinusInf"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isMinusInf(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isMinusInf()"
// params: []
extern "C"
    int casadi__SXElement__isMinusInf(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isMinusInf(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isMinusInf();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isMinusOne" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isMinusOne"
// cWrapperName: "casadi__SXElement__isMinusOne"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isMinusOne(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isMinusOne()"
// params: []
extern "C"
    int casadi__SXElement__isMinusOne(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isMinusOne(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isMinusOne();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isNan" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isNan"
// cWrapperName: "casadi__SXElement__isNan"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isNan(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isNan()"
// params: []
extern "C"
    int casadi__SXElement__isNan(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isNan(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isNan();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isNonNegative" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isNonNegative"
// cWrapperName: "casadi__SXElement__isNonNegative"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isNonNegative(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isNonNegative()"
// params: []
extern "C"
    int casadi__SXElement__isNonNegative(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isNonNegative(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isNonNegative();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isNull" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isNull"
// cWrapperName: "casadi__SXElement__isNull"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isNull(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isNull()"
// params: []
extern "C"
    int casadi__SXElement__isNull(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isNull(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isNull();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isOne" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isOne"
// cWrapperName: "casadi__SXElement__isOne"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isOne(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isOne()"
// params: []
extern "C"
    int casadi__SXElement__isOne(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isOne(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isOne();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isOp" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isOp"
// cWrapperName: "casadi__SXElement__isOp"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isOp(std::string ** err_msg, casadi::SXElement* obj, int x0)"
// call: "obj->isOp(x0_)"
// params: [CInt]
extern "C"
    int casadi__SXElement__isOp(std::string ** err_msg, casadi::SXElement* obj, int x0);
int casadi__SXElement__isOp(std::string ** err_msg, casadi::SXElement* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        bool ret = obj->isOp(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isRegular" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isRegular"
// cWrapperName: "casadi__SXElement__isRegular"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isRegular(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isRegular()"
// params: []
extern "C"
    int casadi__SXElement__isRegular(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isRegular(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isRegular();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSymbolic" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isSymbolic"
// cWrapperName: "casadi__SXElement__isSymbolic"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isSymbolic(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isSymbolic()"
// params: []
extern "C"
    int casadi__SXElement__isSymbolic(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isSymbolic(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isSymbolic();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isZero" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::isZero"
// cWrapperName: "casadi__SXElement__isZero"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__isZero(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->isZero()"
// params: []
extern "C"
    int casadi__SXElement__isZero(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__isZero(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->isZero();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "log" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::log"
// cWrapperName: "casadi__SXElement__log"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__log(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->log()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__log(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__log(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->log();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "log10" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::log10"
// cWrapperName: "casadi__SXElement__log10"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__log10(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->log10()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__log10(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__log10(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->log10();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "logic_and" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::logic_and"
// cWrapperName: "casadi__SXElement__logic_and"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__logic_and(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->logic_and(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__logic_and(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__logic_and(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->logic_and(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "logic_not" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::logic_not"
// cWrapperName: "casadi__SXElement__logic_not"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__logic_not(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->logic_not()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__logic_not(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__logic_not(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->logic_not();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "logic_or" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::logic_or"
// cWrapperName: "casadi__SXElement__logic_or"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__logic_or(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->logic_or(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__logic_or(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__logic_or(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->logic_or(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mark" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::mark"
// cWrapperName: "casadi__SXElement__mark"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SXElement__mark(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->mark()"
// params: []
extern "C"
    void casadi__SXElement__mark(std::string ** err_msg, casadi::SXElement* obj);
void casadi__SXElement__mark(std::string ** err_msg, casadi::SXElement* obj){
    try {

    obj->mark();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "marked" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::marked"
// cWrapperName: "casadi__SXElement__marked"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SXElement__marked(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->marked()"
// params: []
extern "C"
    int casadi__SXElement__marked(std::string ** err_msg, casadi::SXElement* obj);
int casadi__SXElement__marked(std::string ** err_msg, casadi::SXElement* obj){
    try {

        bool ret = obj->marked();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "mul" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::mul"
// cWrapperName: "casadi__SXElement__mul"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__mul(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->mul(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__mul(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__mul(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->mul(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "printme" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::printme"
// cWrapperName: "casadi__SXElement__printme"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__printme(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)"
// call: "obj->printme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__printme(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0);
casadi::SXElement* casadi__SXElement__printme(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){
    try {
        casadi::SXElement x0_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x0);

        casadi::SXElement ret = obj->printme(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setTemp" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::setTemp"
// cWrapperName: "casadi__SXElement__setTemp"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SXElement__setTemp(std::string ** err_msg, casadi::SXElement* obj, int x0)"
// call: "obj->setTemp(x0_)"
// params: [CInt]
extern "C"
    void casadi__SXElement__setTemp(std::string ** err_msg, casadi::SXElement* obj, int x0);
void casadi__SXElement__setTemp(std::string ** err_msg, casadi::SXElement* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setTemp(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sign" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::sign"
// cWrapperName: "casadi__SXElement__sign"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__sign(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->sign()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__sign(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__sign(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->sign();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sin" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::sin"
// cWrapperName: "casadi__SXElement__sin"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__sin(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->sin()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__sin(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__sin(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->sin();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sinh" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::sinh"
// cWrapperName: "casadi__SXElement__sinh"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__sinh(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->sinh()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__sinh(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__sinh(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->sinh();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sq" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::sq"
// cWrapperName: "casadi__SXElement__sq"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__sq(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->sq()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__sq(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__sq(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->sq();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sqrt" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::sqrt"
// cWrapperName: "casadi__SXElement__sqrt"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__sqrt(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->sqrt()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__sqrt(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__sqrt(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->sqrt();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sym" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::sym"
// cWrapperName: "casadi__SXElement__sym"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__sym(std::string ** err_msg, std::string* x0)"
// call: "casadi::SXElement::sym(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SXElement* casadi__SXElement__sym(std::string ** err_msg, std::string* x0);
casadi::SXElement* casadi__SXElement__sym(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SXElement ret = casadi::SXElement::sym(x0_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tan" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::tan"
// cWrapperName: "casadi__SXElement__tan"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__tan(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->tan()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__tan(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__tan(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->tan();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tanh" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::tanh"
// cWrapperName: "casadi__SXElement__tanh"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__tanh(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->tanh()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__tanh(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__tanh(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->tanh();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "trans" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::trans"
// cWrapperName: "casadi__SXElement__trans"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__trans(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->trans()"
// params: []
extern "C"
    casadi::SXElement* casadi__SXElement__trans(std::string ** err_msg, casadi::SXElement* obj);
casadi::SXElement* casadi__SXElement__trans(std::string ** err_msg, casadi::SXElement* obj){
    try {

        casadi::SXElement ret = obj->trans();
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "unary" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::unary"
// cWrapperName: "casadi__SXElement__unary"
// protoArgs: "(std::string ** err_msg, int x0, casadi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SXElement__unary(std::string ** err_msg, int x0, casadi::SXElement* x1)"
// call: "casadi::SXElement::unary(x0_, x1_)"
// params: [CInt,Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    casadi::SXElement* casadi__SXElement__unary(std::string ** err_msg, int x0, casadi::SXElement* x1);
casadi::SXElement* casadi__SXElement__unary(std::string ** err_msg, int x0, casadi::SXElement* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        casadi::SXElement x1_ = Marshaling<casadi::SXElement,casadi::SXElement*>::marshal(x1);

        casadi::SXElement ret = casadi::SXElement::unary(x0_, x1_);
        return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SXFunction")===============
// classType: UserType (Namespace ["casadi"]) (Name "SXFunction")
extern "C"
    void delete_casadi__SXFunction(casadi::SXFunction* obj);
void delete_casadi__SXFunction(casadi::SXFunction* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction"
// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
// cWrapperRetType: "casadi::SXFunction*"
// proto: "casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1)"
// call: "casadi::SXFunction(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX"))))]
extern "C"
    casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1);
casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__0(std::string ** err_msg, std::vector< casadi::SX* >* x0, std::vector< casadi::SX* >* x1){
    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);

        casadi::SXFunction ret = casadi::SXFunction(x0_, x1_);
        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction"
// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::Function* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
// cWrapperRetType: "casadi::SXFunction*"
// proto: "casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0)"
// call: "casadi::SXFunction(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0);
casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__1(std::string ** err_msg, casadi::Function* x0){
    try {
        casadi::Function x0_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x0);

        casadi::SXFunction ret = casadi::SXFunction(x0_);
        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction"
// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::MXFunction* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
// cWrapperRetType: "casadi::SXFunction*"
// proto: "casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__2(std::string ** err_msg, casadi::MXFunction* x0)"
// call: "casadi::SXFunction(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MXFunction")))]
extern "C"
    casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__2(std::string ** err_msg, casadi::MXFunction* x0);
casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__2(std::string ** err_msg, casadi::MXFunction* x0){
    try {
        casadi::MXFunction x0_ = Marshaling<casadi::MXFunction,casadi::MXFunction*>::marshal(x0);

        casadi::SXFunction ret = casadi::SXFunction(x0_);
        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction"
// cWrapperName: "casadi__SXFunction__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SXFunction")
// cWrapperRetType: "casadi::SXFunction*"
// proto: "casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__3(std::string ** err_msg)"
// call: "casadi::SXFunction()"
// params: []
extern "C"
    casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__3(std::string ** err_msg);
casadi::SXFunction* casadi__SXFunction__CONSTRUCTOR__3(std::string ** err_msg){
    try {

        casadi::SXFunction ret = casadi::SXFunction();
        return WrapReturn< casadi::SXFunction*, casadi::SXFunction >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "clearSymbolic" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::clearSymbolic"
// cWrapperName: "casadi__SXFunction__clearSymbolic"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SXFunction__clearSymbolic(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->clearSymbolic()"
// params: []
extern "C"
    void casadi__SXFunction__clearSymbolic(std::string ** err_msg, casadi::SXFunction* obj);
void casadi__SXFunction__clearSymbolic(std::string ** err_msg, casadi::SXFunction* obj){
    try {

    obj->clearSymbolic();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "countNodes" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::countNodes"
// cWrapperName: "casadi__SXFunction__countNodes"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXFunction__countNodes(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->countNodes()"
// params: []
extern "C"
    int casadi__SXFunction__countNodes(std::string ** err_msg, casadi::SXFunction* obj);
int casadi__SXFunction__countNodes(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        int ret = obj->countNodes();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getAlgorithmSize" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::getAlgorithmSize"
// cWrapperName: "casadi__SXFunction__getAlgorithmSize"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXFunction__getAlgorithmSize(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->getAlgorithmSize()"
// params: []
extern "C"
    int casadi__SXFunction__getAlgorithmSize(std::string ** err_msg, casadi::SXFunction* obj);
int casadi__SXFunction__getAlgorithmSize(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        int ret = obj->getAlgorithmSize();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getAtomicInputReal" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::getAtomicInputReal"
// cWrapperName: "casadi__SXFunction__getAtomicInputReal"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__SXFunction__getAtomicInputReal(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->getAtomicInputReal(x0_)"
// params: [CInt]
extern "C"
    double casadi__SXFunction__getAtomicInputReal(std::string ** err_msg, casadi::SXFunction* obj, int x0);
double casadi__SXFunction__getAtomicInputReal(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        double ret = obj->getAtomicInputReal(x0_);
        return WrapReturn< double, double >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getAtomicOperation" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::getAtomicOperation"
// cWrapperName: "casadi__SXFunction__getAtomicOperation"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXFunction__getAtomicOperation(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->getAtomicOperation(x0_)"
// params: [CInt]
extern "C"
    int casadi__SXFunction__getAtomicOperation(std::string ** err_msg, casadi::SXFunction* obj, int x0);
int casadi__SXFunction__getAtomicOperation(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        int ret = obj->getAtomicOperation(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getAtomicOutput" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::getAtomicOutput"
// cWrapperName: "casadi__SXFunction__getAtomicOutput"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXFunction__getAtomicOutput(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->getAtomicOutput(x0_)"
// params: [CInt]
extern "C"
    int casadi__SXFunction__getAtomicOutput(std::string ** err_msg, casadi::SXFunction* obj, int x0);
int casadi__SXFunction__getAtomicOutput(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        int ret = obj->getAtomicOutput(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getFree" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::getFree"
// cWrapperName: "casadi__SXFunction__getFree"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: StdVec (UserType (Namespace ["casadi"]) (Name "SXElement"))
// cWrapperRetType: "std::vector< casadi::SXElement* >*"
// proto: "std::vector< casadi::SXElement* >* casadi__SXFunction__getFree(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->getFree()"
// params: []
extern "C"
    std::vector< casadi::SXElement* >* casadi__SXFunction__getFree(std::string ** err_msg, casadi::SXFunction* obj);
std::vector< casadi::SXElement* >* casadi__SXFunction__getFree(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        std::vector< casadi::SXElement > ret = obj->getFree();
        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;
    }
}


// ================== Normal method: "getWorkSize" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::getWorkSize"
// cWrapperName: "casadi__SXFunction__getWorkSize"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__SXFunction__getWorkSize(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->getWorkSize()"
// params: []
extern "C"
    int casadi__SXFunction__getWorkSize(std::string ** err_msg, casadi::SXFunction* obj);
int casadi__SXFunction__getWorkSize(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        int ret = obj->getWorkSize();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__0"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__grad__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
casadi::SX* casadi__SXFunction__grad__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__1"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__grad__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
casadi::SX* casadi__SXFunction__grad__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__2"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// call: "obj->grad(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__grad__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
casadi::SX* casadi__SXFunction__grad__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = obj->grad(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__3"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->grad(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::SX* casadi__SXFunction__grad__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
casadi::SX* casadi__SXFunction__grad__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__4"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__4(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->grad()"
// params: []
extern "C"
    casadi::SX* casadi__SXFunction__grad__4(std::string ** err_msg, casadi::SXFunction* obj);
casadi::SX* casadi__SXFunction__grad__4(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        casadi::SX ret = obj->grad();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__5"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__5(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->grad(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SXFunction__grad__5(std::string ** err_msg, casadi::SXFunction* obj, int x0);
casadi::SX* casadi__SXFunction__grad__5(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->grad(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "grad" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::grad"
// cWrapperName: "casadi__SXFunction__grad__6"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__grad__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// call: "obj->grad(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SXFunction__grad__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
casadi::SX* casadi__SXFunction__grad__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->grad(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__0"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->hess(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__hess__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
casadi::SX* casadi__SXFunction__hess__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->hess(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__1"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->hess(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__hess__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
casadi::SX* casadi__SXFunction__hess__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->hess(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__2"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// call: "obj->hess(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__hess__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
casadi::SX* casadi__SXFunction__hess__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = obj->hess(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__3"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->hess(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::SX* casadi__SXFunction__hess__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
casadi::SX* casadi__SXFunction__hess__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->hess(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__4"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__4(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->hess()"
// params: []
extern "C"
    casadi::SX* casadi__SXFunction__hess__4(std::string ** err_msg, casadi::SXFunction* obj);
casadi::SX* casadi__SXFunction__hess__4(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        casadi::SX ret = obj->hess();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__5"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__5(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->hess(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SXFunction__hess__5(std::string ** err_msg, casadi::SXFunction* obj, int x0);
casadi::SX* casadi__SXFunction__hess__5(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->hess(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hess" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::hess"
// cWrapperName: "casadi__SXFunction__hess__6"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__hess__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// call: "obj->hess(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SXFunction__hess__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
casadi::SX* casadi__SXFunction__hess__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->hess(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "inputExpr" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::inputExpr"
// cWrapperName: "casadi__SXFunction__inputExpr__0"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__SXFunction__inputExpr__0(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->inputExpr()"
// params: []
extern "C"
    std::vector< casadi::SX* >* casadi__SXFunction__inputExpr__0(std::string ** err_msg, casadi::SXFunction* obj);
std::vector< casadi::SX* >* casadi__SXFunction__inputExpr__0(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        std::vector< casadi::SX > ret = obj->inputExpr();
        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;
    }
}


// ================== Normal method: "inputExpr" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::inputExpr"
// cWrapperName: "casadi__SXFunction__inputExpr__1"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__inputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// call: "obj->inputExpr(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__inputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
casadi::SX* casadi__SXFunction__inputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = obj->inputExpr(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "inputExpr" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::inputExpr"
// cWrapperName: "casadi__SXFunction__inputExpr__2"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__inputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->inputExpr(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SXFunction__inputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0);
casadi::SX* casadi__SXFunction__inputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->inputExpr(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__0"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__jac__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
casadi::SX* casadi__SXFunction__jac__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__1"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2);
casadi::SX* casadi__SXFunction__jac__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::SX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__2"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3);
casadi::SX* casadi__SXFunction__jac__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::SX ret = obj->jac(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;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__3"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__3(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__jac__3(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
casadi::SX* casadi__SXFunction__jac__3(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__4"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__4(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [CInt,Ref (Const StdString),CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__4(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2);
casadi::SX* casadi__SXFunction__jac__4(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::SX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__5"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__5(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [CInt,Ref (Const StdString),CBool,CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__5(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3);
casadi::SX* casadi__SXFunction__jac__5(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::SX ret = obj->jac(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;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__6"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__6(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// call: "obj->jac(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__jac__6(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
casadi::SX* casadi__SXFunction__jac__6(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = obj->jac(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__7"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__7(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->jac(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::SX* casadi__SXFunction__jac__7(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
casadi::SX* casadi__SXFunction__jac__7(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__8"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__8(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CInt,CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__8(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2);
casadi::SX* casadi__SXFunction__jac__8(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::SX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__9"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__9(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [Ref (Const StdString),CInt,CBool,CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__9(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3);
casadi::SX* casadi__SXFunction__jac__9(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1, int x2, int x3){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::SX ret = obj->jac(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;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__10"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__10(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->jac()"
// params: []
extern "C"
    casadi::SX* casadi__SXFunction__jac__10(std::string ** err_msg, casadi::SXFunction* obj);
casadi::SX* casadi__SXFunction__jac__10(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        casadi::SX ret = obj->jac();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__11"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__11(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->jac(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SXFunction__jac__11(std::string ** err_msg, casadi::SXFunction* obj, int x0);
casadi::SX* casadi__SXFunction__jac__11(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->jac(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__12"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__12(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// call: "obj->jac(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SXFunction__jac__12(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
casadi::SX* casadi__SXFunction__jac__12(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->jac(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__13"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__13(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
// params: [CInt,CInt,CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__13(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2);
casadi::SX* casadi__SXFunction__jac__13(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::SX ret = obj->jac(x0_, x1_, x2_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "jac" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::jac"
// cWrapperName: "casadi__SXFunction__jac__14"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__jac__14(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,CBool,CBool]
extern "C"
    casadi::SX* casadi__SXFunction__jac__14(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3);
casadi::SX* casadi__SXFunction__jac__14(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1, int x2, int x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::SX ret = obj->jac(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;
    }
}


// ================== Normal method: "outputExpr" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::outputExpr"
// cWrapperName: "casadi__SXFunction__outputExpr__0"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: Const (StdVec (UserType (Namespace ["casadi"]) (Name "SX")))
// cWrapperRetType: "std::vector< casadi::SX* >*"
// proto: "std::vector< casadi::SX* >* casadi__SXFunction__outputExpr__0(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->outputExpr()"
// params: []
extern "C"
    std::vector< casadi::SX* >* casadi__SXFunction__outputExpr__0(std::string ** err_msg, casadi::SXFunction* obj);
std::vector< casadi::SX* >* casadi__SXFunction__outputExpr__0(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        std::vector< casadi::SX > ret = obj->outputExpr();
        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;
    }
}


// ================== Normal method: "outputExpr" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::outputExpr"
// cWrapperName: "casadi__SXFunction__outputExpr__1"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__outputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// call: "obj->outputExpr(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__outputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
casadi::SX* casadi__SXFunction__outputExpr__1(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = obj->outputExpr(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "outputExpr" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::outputExpr"
// cWrapperName: "casadi__SXFunction__outputExpr__2"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "SX"))
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__outputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->outputExpr(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SXFunction__outputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0);
casadi::SX* casadi__SXFunction__outputExpr__2(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->outputExpr(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__0"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__tang__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1);
casadi::SX* casadi__SXFunction__tang__0(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, std::string* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__1"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
// params: [CInt,Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__tang__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1);
casadi::SX* casadi__SXFunction__tang__1(std::string ** err_msg, casadi::SXFunction* obj, int x0, std::string* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

        casadi::SX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__2"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0)"
// call: "obj->tang(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::SX* casadi__SXFunction__tang__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0);
casadi::SX* casadi__SXFunction__tang__2(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::SX ret = obj->tang(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__3"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->tang(x0_, x1_)"
// params: [Ref (Const StdString),CInt]
extern "C"
    casadi::SX* casadi__SXFunction__tang__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1);
casadi::SX* casadi__SXFunction__tang__3(std::string ** err_msg, casadi::SXFunction* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__4"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__4(std::string ** err_msg, casadi::SXFunction* obj)"
// call: "obj->tang()"
// params: []
extern "C"
    casadi::SX* casadi__SXFunction__tang__4(std::string ** err_msg, casadi::SXFunction* obj);
casadi::SX* casadi__SXFunction__tang__4(std::string ** err_msg, casadi::SXFunction* obj){
    try {

        casadi::SX ret = obj->tang();
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__5"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__5(std::string ** err_msg, casadi::SXFunction* obj, int x0)"
// call: "obj->tang(x0_)"
// params: [CInt]
extern "C"
    casadi::SX* casadi__SXFunction__tang__5(std::string ** err_msg, casadi::SXFunction* obj, int x0);
casadi::SX* casadi__SXFunction__tang__5(std::string ** err_msg, casadi::SXFunction* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::SX ret = obj->tang(x0_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "tang" ===============
// class: "casadi::SXFunction"
// cppName: "casadi::SXFunction::tang"
// cWrapperName: "casadi__SXFunction__tang__6"
// protoArgs: "(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SXFunction__tang__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1)"
// call: "obj->tang(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::SX* casadi__SXFunction__tang__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1);
casadi::SX* casadi__SXFunction__tang__6(std::string ** err_msg, casadi::SXFunction* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SX ret = obj->tang(x0_, x1_);
        return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SharedObject")===============
// classType: UserType (Namespace ["casadi"]) (Name "SharedObject")
extern "C"
    void delete_casadi__SharedObject(casadi::SharedObject* obj);
void delete_casadi__SharedObject(casadi::SharedObject* obj){
    delete obj;
}

// ================== Normal method: "assertInit" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::assertInit"
// cWrapperName: "casadi__SharedObject__assertInit"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SharedObject__assertInit(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->assertInit()"
// params: []
extern "C"
    void casadi__SharedObject__assertInit(std::string ** err_msg, casadi::SharedObject* obj);
void casadi__SharedObject__assertInit(std::string ** err_msg, casadi::SharedObject* obj){
    try {

    obj->assertInit();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "checkNode" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::checkNode"
// cWrapperName: "casadi__SharedObject__checkNode"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SharedObject__checkNode(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->checkNode()"
// params: []
extern "C"
    int casadi__SharedObject__checkNode(std::string ** err_msg, casadi::SharedObject* obj);
int casadi__SharedObject__checkNode(std::string ** err_msg, casadi::SharedObject* obj){
    try {

        bool ret = obj->checkNode();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "init" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::init"
// cWrapperName: "casadi__SharedObject__init__0"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SharedObject__init__0(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->init()"
// params: []
extern "C"
    void casadi__SharedObject__init__0(std::string ** err_msg, casadi::SharedObject* obj);
void casadi__SharedObject__init__0(std::string ** err_msg, casadi::SharedObject* obj){
    try {

    obj->init();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "init" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::init"
// cWrapperName: "casadi__SharedObject__init__1"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SharedObject__init__1(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
// call: "obj->init(x0_)"
// params: [CBool]
extern "C"
    void casadi__SharedObject__init__1(std::string ** err_msg, casadi::SharedObject* obj, int x0);
void casadi__SharedObject__init__1(std::string ** err_msg, casadi::SharedObject* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->init(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "isInit" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::isInit"
// cWrapperName: "casadi__SharedObject__isInit"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SharedObject__isInit(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->isInit()"
// params: []
extern "C"
    int casadi__SharedObject__isInit(std::string ** err_msg, casadi::SharedObject* obj);
int casadi__SharedObject__isInit(std::string ** err_msg, casadi::SharedObject* obj){
    try {

        bool ret = obj->isInit();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isNull" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::isNull"
// cWrapperName: "casadi__SharedObject__isNull"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__SharedObject__isNull(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->isNull()"
// params: []
extern "C"
    int casadi__SharedObject__isNull(std::string ** err_msg, casadi::SharedObject* obj);
int casadi__SharedObject__isNull(std::string ** err_msg, casadi::SharedObject* obj){
    try {

        bool ret = obj->isNull();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "makeUnique" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::makeUnique"
// cWrapperName: "casadi__SharedObject__makeUnique__0"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SharedObject__makeUnique__0(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->makeUnique()"
// params: []
extern "C"
    void casadi__SharedObject__makeUnique__0(std::string ** err_msg, casadi::SharedObject* obj);
void casadi__SharedObject__makeUnique__0(std::string ** err_msg, casadi::SharedObject* obj){
    try {

    obj->makeUnique();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "makeUnique" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::makeUnique"
// cWrapperName: "casadi__SharedObject__makeUnique__1"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SharedObject__makeUnique__1(std::string ** err_msg, casadi::SharedObject* obj, int x0)"
// call: "obj->makeUnique(x0_)"
// params: [CBool]
extern "C"
    void casadi__SharedObject__makeUnique__1(std::string ** err_msg, casadi::SharedObject* obj, int x0);
void casadi__SharedObject__makeUnique__1(std::string ** err_msg, casadi::SharedObject* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->makeUnique(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printPtr" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::printPtr"
// cWrapperName: "casadi__SharedObject__printPtr"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->printPtr()"
// params: []
extern "C"
    void casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj);
void casadi__SharedObject__printPtr(std::string ** err_msg, casadi::SharedObject* obj){
    try {

    obj->printPtr();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "Simulator")===============
// classType: UserType (Namespace ["casadi"]) (Name "Simulator")
extern "C"
    void delete_casadi__Simulator(casadi::Simulator* obj);
void delete_casadi__Simulator(casadi::Simulator* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Simulator"
// cppName: "casadi::Simulator"
// cWrapperName: "casadi__Simulator__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
// cWrapperRetType: "casadi::Simulator*"
// proto: "casadi::Simulator* casadi__Simulator__CONSTRUCTOR__0(std::string ** err_msg, casadi::Integrator* x0, casadi::DMatrix* x1)"
// call: "casadi::Simulator(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::Simulator* casadi__Simulator__CONSTRUCTOR__0(std::string ** err_msg, casadi::Integrator* x0, casadi::DMatrix* x1);
casadi::Simulator* casadi__Simulator__CONSTRUCTOR__0(std::string ** err_msg, casadi::Integrator* x0, casadi::DMatrix* x1){
    try {
        casadi::Integrator x0_ = Marshaling<casadi::Integrator,casadi::Integrator*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x1);

        casadi::Simulator ret = casadi::Simulator(x0_, x1_);
        return WrapReturn< casadi::Simulator*, casadi::Simulator >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Simulator"
// cppName: "casadi::Simulator"
// cWrapperName: "casadi__Simulator__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
// cWrapperRetType: "casadi::Simulator*"
// proto: "casadi::Simulator* casadi__Simulator__CONSTRUCTOR__1(std::string ** err_msg, casadi::Integrator* x0, std::vector< double >* x1)"
// call: "casadi::Simulator(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (StdVec CDouble))]
extern "C"
    casadi::Simulator* casadi__Simulator__CONSTRUCTOR__1(std::string ** err_msg, casadi::Integrator* x0, std::vector< double >* x1);
casadi::Simulator* casadi__Simulator__CONSTRUCTOR__1(std::string ** err_msg, casadi::Integrator* x0, std::vector< double >* x1){
    try {
        casadi::Integrator x0_ = Marshaling<casadi::Integrator,casadi::Integrator*>::marshal(x0);
        std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

        casadi::Simulator ret = casadi::Simulator(x0_, x1_);
        return WrapReturn< casadi::Simulator*, casadi::Simulator >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Simulator"
// cppName: "casadi::Simulator"
// cWrapperName: "casadi__Simulator__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, casadi::DMatrix* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
// cWrapperRetType: "casadi::Simulator*"
// proto: "casadi::Simulator* casadi__Simulator__CONSTRUCTOR__2(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, casadi::DMatrix* x2)"
// call: "casadi::Simulator(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    casadi::Simulator* casadi__Simulator__CONSTRUCTOR__2(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, casadi::DMatrix* x2);
casadi::Simulator* casadi__Simulator__CONSTRUCTOR__2(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, casadi::DMatrix* x2){
    try {
        casadi::Integrator x0_ = Marshaling<casadi::Integrator,casadi::Integrator*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);
        casadi::DMatrix x2_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x2);

        casadi::Simulator ret = casadi::Simulator(x0_, x1_, x2_);
        return WrapReturn< casadi::Simulator*, casadi::Simulator >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Simulator"
// cppName: "casadi::Simulator"
// cWrapperName: "casadi__Simulator__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
// cWrapperRetType: "casadi::Simulator*"
// proto: "casadi::Simulator* casadi__Simulator__CONSTRUCTOR__3(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, std::vector< double >* x2)"
// call: "casadi::Simulator(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Integrator"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function"))),Ref (Const (StdVec CDouble))]
extern "C"
    casadi::Simulator* casadi__Simulator__CONSTRUCTOR__3(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, std::vector< double >* x2);
casadi::Simulator* casadi__Simulator__CONSTRUCTOR__3(std::string ** err_msg, casadi::Integrator* x0, casadi::Function* x1, std::vector< double >* x2){
    try {
        casadi::Integrator x0_ = Marshaling<casadi::Integrator,casadi::Integrator*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);
        std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

        casadi::Simulator ret = casadi::Simulator(x0_, x1_, x2_);
        return WrapReturn< casadi::Simulator*, casadi::Simulator >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Simulator"
// cppName: "casadi::Simulator"
// cWrapperName: "casadi__Simulator__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Simulator")
// cWrapperRetType: "casadi::Simulator*"
// proto: "casadi::Simulator* casadi__Simulator__CONSTRUCTOR__4(std::string ** err_msg)"
// call: "casadi::Simulator()"
// params: []
extern "C"
    casadi::Simulator* casadi__Simulator__CONSTRUCTOR__4(std::string ** err_msg);
casadi::Simulator* casadi__Simulator__CONSTRUCTOR__4(std::string ** err_msg){
    try {

        casadi::Simulator ret = casadi::Simulator();
        return WrapReturn< casadi::Simulator*, casadi::Simulator >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "Slice")===============
// classType: UserType (Namespace ["casadi"]) (Name "Slice")
extern "C"
    void delete_casadi__Slice(casadi::Slice* obj);
void delete_casadi__Slice(casadi::Slice* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice"
// cWrapperName: "casadi__Slice__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
// cWrapperRetType: "casadi::Slice*"
// proto: "casadi::Slice* casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1)"
// call: "casadi::Slice(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (UserType (Namespace ["casadi"]) (Name "Slice"))]
extern "C"
    casadi::Slice* casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1);
casadi::Slice* casadi__Slice__CONSTRUCTOR__0(std::string ** err_msg, std::vector< int >* x0, casadi::Slice* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        casadi::Slice x1_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x1);

        casadi::Slice ret = casadi::Slice(x0_, x1_);
        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice"
// cWrapperName: "casadi__Slice__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
// cWrapperRetType: "casadi::Slice*"
// proto: "casadi::Slice* casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::Slice(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::Slice* casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0);
casadi::Slice* casadi__Slice__CONSTRUCTOR__1(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::Slice ret = casadi::Slice(x0_);
        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice"
// cWrapperName: "casadi__Slice__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
// cWrapperRetType: "casadi::Slice*"
// proto: "casadi::Slice* casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Slice(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Slice* casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, int x0, int x1);
casadi::Slice* casadi__Slice__CONSTRUCTOR__2(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Slice ret = casadi::Slice(x0_, x1_);
        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice"
// cWrapperName: "casadi__Slice__CONSTRUCTOR__3"
// protoArgs: "(std::string ** err_msg, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
// cWrapperRetType: "casadi::Slice*"
// proto: "casadi::Slice* casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1, int x2)"
// call: "casadi::Slice(x0_, x1_, x2_)"
// params: [CInt,CInt,CInt]
extern "C"
    casadi::Slice* casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1, int x2);
casadi::Slice* casadi__Slice__CONSTRUCTOR__3(std::string ** err_msg, int x0, int x1, int x2){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);

        casadi::Slice ret = casadi::Slice(x0_, x1_, x2_);
        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice"
// cWrapperName: "casadi__Slice__CONSTRUCTOR__4"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
// cWrapperRetType: "casadi::Slice*"
// proto: "casadi::Slice* casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg, int x0)"
// call: "casadi::Slice(x0_)"
// params: [CInt]
extern "C"
    casadi::Slice* casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg, int x0);
casadi::Slice* casadi__Slice__CONSTRUCTOR__4(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Slice ret = casadi::Slice(x0_);
        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice"
// cWrapperName: "casadi__Slice__CONSTRUCTOR__5"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Slice")
// cWrapperRetType: "casadi::Slice*"
// proto: "casadi::Slice* casadi__Slice__CONSTRUCTOR__5(std::string ** err_msg)"
// call: "casadi::Slice()"
// params: []
extern "C"
    casadi::Slice* casadi__Slice__CONSTRUCTOR__5(std::string ** err_msg);
casadi::Slice* casadi__Slice__CONSTRUCTOR__5(std::string ** err_msg){
    try {

        casadi::Slice ret = casadi::Slice();
        return WrapReturn< casadi::Slice*, casadi::Slice >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getAll" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice::getAll"
// cWrapperName: "casadi__Slice__getAll__0"
// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Slice__getAll__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1)"
// call: "obj->getAll(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Slice"))),CInt]
extern "C"
    std::vector< int >* casadi__Slice__getAll__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1);
std::vector< int >* casadi__Slice__getAll__0(std::string ** err_msg, casadi::Slice* obj, casadi::Slice* x0, int x1){
    try {
        casadi::Slice x0_ = Marshaling<casadi::Slice,casadi::Slice*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        std::vector< int > ret = obj->getAll(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;
    }
}


// ================== Normal method: "getAll" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice::getAll"
// cWrapperName: "casadi__Slice__getAll__1"
// protoArgs: "(std::string ** err_msg, casadi::Slice* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Slice__getAll__1(std::string ** err_msg, casadi::Slice* obj, int x0)"
// call: "obj->getAll(x0_)"
// params: [CInt]
extern "C"
    std::vector< int >* casadi__Slice__getAll__1(std::string ** err_msg, casadi::Slice* obj, int x0);
std::vector< int >* casadi__Slice__getAll__1(std::string ** err_msg, casadi::Slice* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        std::vector< int > ret = obj->getAll(x0_);
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "isSlice" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice::isSlice"
// cWrapperName: "casadi__Slice__isSlice"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Slice__isSlice(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::Slice::isSlice(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    int casadi__Slice__isSlice(std::string ** err_msg, std::vector< int >* x0);
int casadi__Slice__isSlice(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::Slice::isSlice(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "isSlice2" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice::isSlice2"
// cWrapperName: "casadi__Slice__isSlice2"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Slice__isSlice2(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::Slice::isSlice2(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    int casadi__Slice__isSlice2(std::string ** err_msg, std::vector< int >* x0);
int casadi__Slice__isSlice2(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::Slice::isSlice2(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "Sparsity")===============
// classType: UserType (Namespace ["casadi"]) (Name "Sparsity")
extern "C"
    void delete_casadi__Sparsity(casadi::Sparsity* obj);
void delete_casadi__Sparsity(casadi::Sparsity* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity"
// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "casadi::Sparsity(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

        casadi::Sparsity ret = casadi::Sparsity(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity"
// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg)"
// call: "casadi::Sparsity()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg);
casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__1(std::string ** err_msg){
    try {

        casadi::Sparsity ret = casadi::Sparsity();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity"
// cWrapperName: "casadi__Sparsity__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__CONSTRUCTOR__2(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "append" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::append"
// cWrapperName: "casadi__Sparsity__append"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->append(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    void casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
void casadi__Sparsity__append(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

    obj->append(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "appendColumns" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::appendColumns"
// cWrapperName: "casadi__Sparsity__appendColumns"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->appendColumns(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    void casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
void casadi__Sparsity__appendColumns(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

    obj->appendColumns(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "band" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::band"
// cWrapperName: "casadi__Sparsity__band"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__band(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Sparsity::band(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__band(std::string ** err_msg, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__band(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = casadi::Sparsity::band(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "banded" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::banded"
// cWrapperName: "casadi__Sparsity__banded"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Sparsity::banded(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__banded(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = casadi::Sparsity::banded(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "clearCache" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::clearCache"
// cWrapperName: "casadi__Sparsity__clearCache"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__clearCache(std::string ** err_msg)"
// call: "casadi::Sparsity::clearCache()"
// params: []
extern "C"
    void casadi__Sparsity__clearCache(std::string ** err_msg);
void casadi__Sparsity__clearCache(std::string ** err_msg){
    try {

    casadi::Sparsity::clearCache();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "colind" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::colind"
// cWrapperName: "casadi__Sparsity__colind__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__colind__0(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->colind(x0_)"
// params: [CInt]
extern "C"
    int casadi__Sparsity__colind__0(std::string ** err_msg, casadi::Sparsity* obj, int x0);
int casadi__Sparsity__colind__0(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        int ret = obj->colind(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "colind" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::colind"
// cWrapperName: "casadi__Sparsity__colind__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__colind__1(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->colind()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__colind__1(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__colind__1(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->colind();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "compress" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::compress"
// cWrapperName: "casadi__Sparsity__compress"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->compress()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__compress(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->compress();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "compressed" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::compressed"
// cWrapperName: "casadi__Sparsity__compressed"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0)"
// call: "casadi::Sparsity::compressed(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0);
casadi::Sparsity* casadi__Sparsity__compressed(std::string ** err_msg, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::compressed(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "dense" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::dense"
// cWrapperName: "casadi__Sparsity__dense__0"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__dense__0(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity::dense(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__dense__0(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__dense__0(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::dense(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "dense" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::dense"
// cWrapperName: "casadi__Sparsity__dense__1"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__dense__1(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Sparsity::dense(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__dense__1(std::string ** err_msg, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__dense__1(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = casadi::Sparsity::dense(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "depthFirstSearch" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::depthFirstSearch"
// cWrapperName: "casadi__Sparsity__depthFirstSearch"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__depthFirstSearch(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
// call: "obj->depthFirstSearch(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [CInt,CInt,Ref (StdVec CInt),Ref (StdVec CInt),Ref (Const (StdVec CInt)),Ref (StdVec CBool)]
extern "C"
    int casadi__Sparsity__depthFirstSearch(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5);
int casadi__Sparsity__depthFirstSearch(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
        std::vector< bool > x5_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x5);

        int ret = obj->depthFirstSearch(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "diag" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::diag"
// cWrapperName: "casadi__Sparsity__diag__0"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__diag__0(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Sparsity::diag(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__diag__0(std::string ** err_msg, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__diag__0(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = casadi::Sparsity::diag(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "diag" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::diag"
// cWrapperName: "casadi__Sparsity__diag__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__diag__1(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity::diag(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__diag__1(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__diag__1(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::diag(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "dimString" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::dimString"
// cWrapperName: "casadi__Sparsity__dimString"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Sparsity__dimString(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->dimString()"
// params: []
extern "C"
    std::string* casadi__Sparsity__dimString(std::string ** err_msg, casadi::Sparsity* obj);
std::string* casadi__Sparsity__dimString(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::string ret = obj->dimString();
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "dulmageMendelsohn" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::dulmageMendelsohn"
// cWrapperName: "casadi__Sparsity__dulmageMendelsohn__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__dulmageMendelsohn__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5)"
// call: "obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt)]
extern "C"
    int casadi__Sparsity__dulmageMendelsohn__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5);
int casadi__Sparsity__dulmageMendelsohn__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::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< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
        std::vector< int > x5_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x5);

        int ret = obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "dulmageMendelsohn" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::dulmageMendelsohn"
// cWrapperName: "casadi__Sparsity__dulmageMendelsohn__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__dulmageMendelsohn__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6)"
// call: "obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// params: [Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),Ref (StdVec CInt),CInt]
extern "C"
    int casadi__Sparsity__dulmageMendelsohn__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6);
int casadi__Sparsity__dulmageMendelsohn__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5, int x6){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::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< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
        std::vector< int > x5_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x5);
        int x6_ = Marshaling<int,int>::marshal(x6);

        int ret = obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "eliminationTree" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::eliminationTree"
// cWrapperName: "casadi__Sparsity__eliminationTree__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__eliminationTree__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->eliminationTree()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__eliminationTree__0(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__eliminationTree__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->eliminationTree();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "eliminationTree" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::eliminationTree"
// cWrapperName: "casadi__Sparsity__eliminationTree__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__eliminationTree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->eliminationTree(x0_)"
// params: [CBool]
extern "C"
    std::vector< int >* casadi__Sparsity__eliminationTree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
std::vector< int >* casadi__Sparsity__eliminationTree__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        std::vector< int > ret = obj->eliminationTree(x0_);
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "enlarge" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::enlarge"
// cWrapperName: "casadi__Sparsity__enlarge"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__enlarge(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    void casadi__Sparsity__enlarge(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void casadi__Sparsity__enlarge(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

    obj->enlarge(x0_, x1_, x2_, x3_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "enlargeColumns" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::enlargeColumns"
// cWrapperName: "casadi__Sparsity__enlargeColumns"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__enlargeColumns(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
// call: "obj->enlargeColumns(x0_, x1_)"
// params: [CInt,Ref (Const (StdVec CInt))]
extern "C"
    void casadi__Sparsity__enlargeColumns(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1);
void casadi__Sparsity__enlargeColumns(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->enlargeColumns(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "enlargeRows" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::enlargeRows"
// cWrapperName: "casadi__Sparsity__enlargeRows"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__enlargeRows(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1)"
// call: "obj->enlargeRows(x0_, x1_)"
// params: [CInt,Ref (Const (StdVec CInt))]
extern "C"
    void casadi__Sparsity__enlargeRows(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1);
void casadi__Sparsity__enlargeRows(std::string ** err_msg, casadi::Sparsity* obj, int x0, std::vector< int >* x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->enlargeRows(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "erase" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::erase"
// cWrapperName: "casadi__Sparsity__erase"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__erase(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    std::vector< int >* casadi__Sparsity__erase(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
std::vector< int >* casadi__Sparsity__erase(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< int > ret = obj->erase(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;
    }
}


// ================== Normal method: "getCCS" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getCCS"
// cWrapperName: "casadi__Sparsity__getCCS"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__getCCS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getCCS(x0_, x1_)"
// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
extern "C"
    void casadi__Sparsity__getCCS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__Sparsity__getCCS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->getCCS(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getCRS" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getCRS"
// cWrapperName: "casadi__Sparsity__getCRS"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__getCRS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getCRS(x0_, x1_)"
// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
extern "C"
    void casadi__Sparsity__getCRS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__Sparsity__getCRS(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->getCRS(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getCol" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getCol"
// cWrapperName: "casadi__Sparsity__getCol"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__getCol(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->getCol()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__getCol(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__getCol(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->getCol();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getDiag" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getDiag"
// cWrapperName: "casadi__Sparsity__getDiag"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__getDiag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->getDiag(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__getDiag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
casadi::Sparsity* casadi__Sparsity__getDiag(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::Sparsity ret = obj->getDiag(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getElements" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getElements"
// cWrapperName: "casadi__Sparsity__getElements__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__getElements__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->getElements(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    void casadi__Sparsity__getElements__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
void casadi__Sparsity__getElements__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->getElements(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getElements" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getElements"
// cWrapperName: "casadi__Sparsity__getElements__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__getElements__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
// call: "obj->getElements(x0_, x1_)"
// params: [Ref (StdVec CInt),CBool]
extern "C"
    void casadi__Sparsity__getElements__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
void casadi__Sparsity__getElements__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

    obj->getElements(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getElements" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getElements"
// cWrapperName: "casadi__Sparsity__getElements__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__getElements__2(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->getElements()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__getElements__2(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__getElements__2(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->getElements();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getElements" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getElements"
// cWrapperName: "casadi__Sparsity__getElements__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__getElements__3(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->getElements(x0_)"
// params: [CBool]
extern "C"
    std::vector< int >* casadi__Sparsity__getElements__3(std::string ** err_msg, casadi::Sparsity* obj, int x0);
std::vector< int >* casadi__Sparsity__getElements__3(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        std::vector< int > ret = obj->getElements(x0_);
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getLowerNZ" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getLowerNZ"
// cWrapperName: "casadi__Sparsity__getLowerNZ"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__getLowerNZ(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->getLowerNZ()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__getLowerNZ(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__getLowerNZ(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->getLowerNZ();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getNZ"
// cWrapperName: "casadi__Sparsity__getNZ__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__getNZ__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getNZ(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    std::vector< int >* casadi__Sparsity__getNZ__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
std::vector< int >* casadi__Sparsity__getNZ__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        std::vector< int > ret = obj->getNZ(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;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getNZ"
// cWrapperName: "casadi__Sparsity__getNZ__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__getNZ__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->getNZ(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__Sparsity__getNZ__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
int casadi__Sparsity__getNZ__1(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        int ret = obj->getNZ(x0_, x1_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZ" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getNZ"
// cWrapperName: "casadi__Sparsity__getNZ__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__getNZ__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->getNZ(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__Sparsity__getNZ__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
int casadi__Sparsity__getNZ__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        int ret = obj->getNZ(x0_, x1_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNZInplace" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getNZInplace"
// cWrapperName: "casadi__Sparsity__getNZInplace"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__getNZInplace(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->getNZInplace(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    void casadi__Sparsity__getNZInplace(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
void casadi__Sparsity__getNZInplace(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->getNZInplace(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getTril" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getTril"
// cWrapperName: "casadi__Sparsity__getTril__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__getTril__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->getTril()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__getTril__0(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__getTril__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->getTril();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getTril" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getTril"
// cWrapperName: "casadi__Sparsity__getTril__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__getTril__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->getTril(x0_)"
// params: [CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__getTril__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
casadi::Sparsity* casadi__Sparsity__getTril__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        casadi::Sparsity ret = obj->getTril(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getTriplet" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getTriplet"
// cWrapperName: "casadi__Sparsity__getTriplet"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__getTriplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getTriplet(x0_, x1_)"
// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
extern "C"
    void casadi__Sparsity__getTriplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
void casadi__Sparsity__getTriplet(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->getTriplet(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "getTriu" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getTriu"
// cWrapperName: "casadi__Sparsity__getTriu__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__getTriu__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->getTriu()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__getTriu__0(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__getTriu__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->getTriu();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getTriu" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getTriu"
// cWrapperName: "casadi__Sparsity__getTriu__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__getTriu__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->getTriu(x0_)"
// params: [CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__getTriu__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
casadi::Sparsity* casadi__Sparsity__getTriu__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        casadi::Sparsity ret = obj->getTriu(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getUpperNZ" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::getUpperNZ"
// cWrapperName: "casadi__Sparsity__getUpperNZ"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__getUpperNZ(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->getUpperNZ()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__getUpperNZ(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__getUpperNZ(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->getUpperNZ();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hasNZ" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::hasNZ"
// cWrapperName: "casadi__Sparsity__hasNZ"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__hasNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    int casadi__Sparsity__hasNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
int casadi__Sparsity__hasNZ(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        bool ret = obj->hasNZ(x0_, x1_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "hash" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::hash"
// cWrapperName: "casadi__Sparsity__hash"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CSize
// cWrapperRetType: "size_t"
// proto: "size_t casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->hash()"
// params: []
extern "C"
    size_t casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj);
size_t casadi__Sparsity__hash(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        size_t ret = obj->hash();
        return WrapReturn< size_t, size_t >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isDense" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isDense"
// cWrapperName: "casadi__Sparsity__isDense"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isDense(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isDense()"
// params: []
extern "C"
    int casadi__Sparsity__isDense(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isDense(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isDense();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isDiagonal" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isDiagonal"
// cWrapperName: "casadi__Sparsity__isDiagonal"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isDiagonal(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isDiagonal()"
// params: []
extern "C"
    int casadi__Sparsity__isDiagonal(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isDiagonal(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isDiagonal();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEmpty" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isEmpty"
// cWrapperName: "casadi__Sparsity__isEmpty__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isEmpty__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isEmpty()"
// params: []
extern "C"
    int casadi__Sparsity__isEmpty__0(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isEmpty__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isEmpty();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEmpty" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isEmpty"
// cWrapperName: "casadi__Sparsity__isEmpty__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isEmpty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->isEmpty(x0_)"
// params: [CBool]
extern "C"
    int casadi__Sparsity__isEmpty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
int casadi__Sparsity__isEmpty__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        bool ret = obj->isEmpty(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEqual" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isEqual"
// cWrapperName: "casadi__Sparsity__isEqual__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isEqual__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->isEqual(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    int casadi__Sparsity__isEqual__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
int casadi__Sparsity__isEqual__0(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

        bool ret = obj->isEqual(x0_, x1_, x2_, x3_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isEqual" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isEqual"
// cWrapperName: "casadi__Sparsity__isEqual__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isEqual__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->isEqual(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    int casadi__Sparsity__isEqual__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
int casadi__Sparsity__isEqual__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        bool ret = obj->isEqual(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isReshape" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isReshape"
// cWrapperName: "casadi__Sparsity__isReshape"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->isReshape(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    int casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
int casadi__Sparsity__isReshape(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        bool ret = obj->isReshape(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isScalar" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isScalar"
// cWrapperName: "casadi__Sparsity__isScalar__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isScalar__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isScalar()"
// params: []
extern "C"
    int casadi__Sparsity__isScalar__0(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isScalar__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isScalar();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isScalar" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isScalar"
// cWrapperName: "casadi__Sparsity__isScalar__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isScalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->isScalar(x0_)"
// params: [CBool]
extern "C"
    int casadi__Sparsity__isScalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
int casadi__Sparsity__isScalar__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        bool ret = obj->isScalar(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSingular" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isSingular"
// cWrapperName: "casadi__Sparsity__isSingular"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isSingular(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isSingular()"
// params: []
extern "C"
    int casadi__Sparsity__isSingular(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isSingular(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isSingular();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSquare" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isSquare"
// cWrapperName: "casadi__Sparsity__isSquare"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isSquare(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isSquare()"
// params: []
extern "C"
    int casadi__Sparsity__isSquare(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isSquare(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isSquare();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isSymmetric" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isSymmetric"
// cWrapperName: "casadi__Sparsity__isSymmetric"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isSymmetric(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isSymmetric()"
// params: []
extern "C"
    int casadi__Sparsity__isSymmetric(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isSymmetric(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isSymmetric();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isTranspose" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isTranspose"
// cWrapperName: "casadi__Sparsity__isTranspose"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isTranspose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->isTranspose(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    int casadi__Sparsity__isTranspose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
int casadi__Sparsity__isTranspose(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        bool ret = obj->isTranspose(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isTril" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isTril"
// cWrapperName: "casadi__Sparsity__isTril"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isTril(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isTril()"
// params: []
extern "C"
    int casadi__Sparsity__isTril(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isTril(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isTril();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isTriu" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isTriu"
// cWrapperName: "casadi__Sparsity__isTriu"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isTriu(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isTriu()"
// params: []
extern "C"
    int casadi__Sparsity__isTriu(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isTriu(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isTriu();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "isVector" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::isVector"
// cWrapperName: "casadi__Sparsity__isVector"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__isVector(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->isVector()"
// params: []
extern "C"
    int casadi__Sparsity__isVector(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__isVector(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->isVector();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "largestFirstOrdering" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::largestFirstOrdering"
// cWrapperName: "casadi__Sparsity__largestFirstOrdering"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__largestFirstOrdering(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->largestFirstOrdering()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__largestFirstOrdering(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__largestFirstOrdering(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->largestFirstOrdering();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "makeDense" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::makeDense"
// cWrapperName: "casadi__Sparsity__makeDense"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->makeDense(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
casadi::Sparsity* casadi__Sparsity__makeDense(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::Sparsity ret = obj->makeDense(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "numel" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::numel"
// cWrapperName: "casadi__Sparsity__numel"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->numel()"
// params: []
extern "C"
    int casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__numel(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->numel();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternCombine" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternCombine"
// cWrapperName: "casadi__Sparsity__patternCombine__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternCombine__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2)"
// call: "obj->patternCombine(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternCombine__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2);
casadi::Sparsity* casadi__Sparsity__patternCombine__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::Sparsity ret = obj->patternCombine(x0_, x1_, x2_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternCombine" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternCombine"
// cWrapperName: "casadi__Sparsity__patternCombine__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternCombine__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3)"
// call: "obj->patternCombine(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CBool,CBool,Ref (StdVec CUChar)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternCombine__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3);
casadi::Sparsity* casadi__Sparsity__patternCombine__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        std::vector< unsigned char > x3_ = Marshaling<std::vector< unsigned char >,std::vector< unsigned char >*>::marshal(x3);

        casadi::Sparsity ret = obj->patternCombine(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternIntersection" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternIntersection"
// cWrapperName: "casadi__Sparsity__patternIntersection__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternIntersection__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->patternIntersection(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternIntersection__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
casadi::Sparsity* casadi__Sparsity__patternIntersection__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = obj->patternIntersection(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternIntersection" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternIntersection"
// cWrapperName: "casadi__Sparsity__patternIntersection__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternIntersection__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1)"
// call: "obj->patternIntersection(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (StdVec CUChar)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternIntersection__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1);
casadi::Sparsity* casadi__Sparsity__patternIntersection__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::vector< unsigned char > x1_ = Marshaling<std::vector< unsigned char >,std::vector< unsigned char >*>::marshal(x1);

        casadi::Sparsity ret = obj->patternIntersection(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternInverse" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternInverse"
// cWrapperName: "casadi__Sparsity__patternInverse"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternInverse(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->patternInverse()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternInverse(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__patternInverse(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->patternInverse();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternProduct" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternProduct"
// cWrapperName: "casadi__Sparsity__patternProduct"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternProduct(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->patternProduct(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternProduct(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
casadi::Sparsity* casadi__Sparsity__patternProduct(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = obj->patternProduct(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternUnion" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternUnion"
// cWrapperName: "casadi__Sparsity__patternUnion__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternUnion__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->patternUnion(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternUnion__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
casadi::Sparsity* casadi__Sparsity__patternUnion__0(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = obj->patternUnion(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "patternUnion" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternUnion"
// cWrapperName: "casadi__Sparsity__patternUnion__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__patternUnion__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1)"
// call: "obj->patternUnion(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),Ref (StdVec CUChar)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternUnion__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1);
casadi::Sparsity* casadi__Sparsity__patternUnion__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, std::vector< unsigned char >* x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        std::vector< unsigned char > x1_ = Marshaling<std::vector< unsigned char >,std::vector< unsigned char >*>::marshal(x1);

        casadi::Sparsity ret = obj->patternUnion(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "pmult" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::pmult"
// cWrapperName: "casadi__Sparsity__pmult__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->pmult(x0_)"
// params: [Ref (Const (StdVec CInt))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
casadi::Sparsity* casadi__Sparsity__pmult__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::Sparsity ret = obj->pmult(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "pmult" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::pmult"
// cWrapperName: "casadi__Sparsity__pmult__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
// call: "obj->pmult(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
casadi::Sparsity* casadi__Sparsity__pmult__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::Sparsity ret = obj->pmult(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "pmult" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::pmult"
// cWrapperName: "casadi__Sparsity__pmult__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
// call: "obj->pmult(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CInt)),CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2);
casadi::Sparsity* casadi__Sparsity__pmult__2(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "pmult" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::pmult"
// cWrapperName: "casadi__Sparsity__pmult__3"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
// call: "obj->pmult(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (StdVec CInt)),CBool,CBool,CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3);
casadi::Sparsity* casadi__Sparsity__pmult__3(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);
        bool x3_ = Marshaling<bool,int>::marshal(x3);

        casadi::Sparsity ret = obj->pmult(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "printCompact" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::printCompact"
// cWrapperName: "casadi__Sparsity__printCompact"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__printCompact(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->printCompact()"
// params: []
extern "C"
    void casadi__Sparsity__printCompact(std::string ** err_msg, casadi::Sparsity* obj);
void casadi__Sparsity__printCompact(std::string ** err_msg, casadi::Sparsity* obj){
    try {

    obj->printCompact();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reCache" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::reCache"
// cWrapperName: "casadi__Sparsity__reCache"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__reCache(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->reCache()"
// params: []
extern "C"
    void casadi__Sparsity__reCache(std::string ** err_msg, casadi::Sparsity* obj);
void casadi__Sparsity__reCache(std::string ** err_msg, casadi::Sparsity* obj){
    try {

    obj->reCache();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "removeDuplicates" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::removeDuplicates"
// cWrapperName: "casadi__Sparsity__removeDuplicates"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->removeDuplicates(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    void casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
void casadi__Sparsity__removeDuplicates(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->removeDuplicates(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reserve" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::reserve"
// cWrapperName: "casadi__Sparsity__reserve"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__reserve(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__Sparsity__reserve(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
void casadi__Sparsity__reserve(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "reshape" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::reshape"
// cWrapperName: "casadi__Sparsity__reshape"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__reshape(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->reshape(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__reshape(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__reshape(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = obj->reshape(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "resize" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::resize"
// cWrapperName: "casadi__Sparsity__resize"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    void casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
void casadi__Sparsity__resize(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "row" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::row"
// cWrapperName: "casadi__Sparsity__row__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__row__0(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->row(x0_)"
// params: [CInt]
extern "C"
    int casadi__Sparsity__row__0(std::string ** err_msg, casadi::Sparsity* obj, int x0);
int casadi__Sparsity__row__0(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        int ret = obj->row(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "row" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::row"
// cWrapperName: "casadi__Sparsity__row__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: Const (StdVec CInt)
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* casadi__Sparsity__row__1(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->row()"
// params: []
extern "C"
    std::vector< int >* casadi__Sparsity__row__1(std::string ** err_msg, casadi::Sparsity* obj);
std::vector< int >* casadi__Sparsity__row__1(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        std::vector< int > ret = obj->row();
        return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "rowcol" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::rowcol"
// cWrapperName: "casadi__Sparsity__rowcol"
// protoArgs: "(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
// call: "casadi::Sparsity::rowcol(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3);
casadi::Sparsity* casadi__Sparsity__rowcol(std::string ** err_msg, std::vector< int >* x0, std::vector< int >* x1, int x2, int x3){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
        int x2_ = Marshaling<int,int>::marshal(x2);
        int x3_ = Marshaling<int,int>::marshal(x3);

        casadi::Sparsity ret = casadi::Sparsity::rowcol(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "rowsSequential" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::rowsSequential"
// cWrapperName: "casadi__Sparsity__rowsSequential__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->rowsSequential()"
// params: []
extern "C"
    int casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__rowsSequential__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        bool ret = obj->rowsSequential();
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "rowsSequential" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::rowsSequential"
// cWrapperName: "casadi__Sparsity__rowsSequential__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->rowsSequential(x0_)"
// params: [CBool]
extern "C"
    int casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
int casadi__Sparsity__rowsSequential__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        bool ret = obj->rowsSequential(x0_);
        return WrapReturn< int, bool >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sanityCheck"
// cWrapperName: "casadi__Sparsity__sanityCheck__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__sanityCheck__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->sanityCheck()"
// params: []
extern "C"
    void casadi__Sparsity__sanityCheck__0(std::string ** err_msg, casadi::Sparsity* obj);
void casadi__Sparsity__sanityCheck__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

    obj->sanityCheck();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "sanityCheck" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sanityCheck"
// cWrapperName: "casadi__Sparsity__sanityCheck__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__sanityCheck__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
// params: [CBool]
extern "C"
    void casadi__Sparsity__sanityCheck__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
void casadi__Sparsity__sanityCheck__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Static method: "scalar" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::scalar"
// cWrapperName: "casadi__Sparsity__scalar__0"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__scalar__0(std::string ** err_msg)"
// call: "casadi::Sparsity::scalar()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__scalar__0(std::string ** err_msg);
casadi::Sparsity* casadi__Sparsity__scalar__0(std::string ** err_msg){
    try {

        casadi::Sparsity ret = casadi::Sparsity::scalar();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "scalar" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::scalar"
// cWrapperName: "casadi__Sparsity__scalar__1"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__scalar__1(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity::scalar(x0_)"
// params: [CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__scalar__1(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__scalar__1(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::scalar(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::size"
// cWrapperName: "casadi__Sparsity__size"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__size(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->size()"
// params: []
extern "C"
    int casadi__Sparsity__size(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__size(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->size();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size1" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::size1"
// cWrapperName: "casadi__Sparsity__size1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->size1()"
// params: []
extern "C"
    int casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__size1(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->size1();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "size2" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::size2"
// cWrapperName: "casadi__Sparsity__size2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->size2()"
// params: []
extern "C"
    int casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__size2(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->size2();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sizeD" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sizeD"
// cWrapperName: "casadi__Sparsity__sizeD"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__sizeD(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->sizeD()"
// params: []
extern "C"
    int casadi__Sparsity__sizeD(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__sizeD(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->sizeD();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sizeL" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sizeL"
// cWrapperName: "casadi__Sparsity__sizeL"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__sizeL(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->sizeL()"
// params: []
extern "C"
    int casadi__Sparsity__sizeL(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__sizeL(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->sizeL();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sizeU" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sizeU"
// cWrapperName: "casadi__Sparsity__sizeU"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__sizeU(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->sizeU()"
// params: []
extern "C"
    int casadi__Sparsity__sizeU(std::string ** err_msg, casadi::Sparsity* obj);
int casadi__Sparsity__sizeU(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        int ret = obj->sizeU();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sparse" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sparse"
// cWrapperName: "casadi__Sparsity__sparse__0"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__sparse__0(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity::sparse(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__sparse__0(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__sparse__0(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::sparse(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "sparse" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sparse"
// cWrapperName: "casadi__Sparsity__sparse__1"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__sparse__1(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Sparsity::sparse(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__sparse__1(std::string ** err_msg, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__sparse__1(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = casadi::Sparsity::sparse(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "spy" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::spy"
// cWrapperName: "casadi__Sparsity__spy"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->spy()"
// params: []
extern "C"
    void casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj);
void casadi__Sparsity__spy(std::string ** err_msg, casadi::Sparsity* obj){
    try {

    obj->spy();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "spyMatlab" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::spyMatlab"
// cWrapperName: "casadi__Sparsity__spyMatlab"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Sparsity__spyMatlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0)"
// call: "obj->spyMatlab(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__Sparsity__spyMatlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0);
void casadi__Sparsity__spyMatlab(std::string ** err_msg, casadi::Sparsity* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->spyMatlab(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "starColoring" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::starColoring"
// cWrapperName: "casadi__Sparsity__starColoring__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__starColoring__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->starColoring()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__starColoring__0(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__starColoring__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->starColoring();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "starColoring" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::starColoring"
// cWrapperName: "casadi__Sparsity__starColoring__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__starColoring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->starColoring(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__starColoring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
casadi::Sparsity* casadi__Sparsity__starColoring__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = obj->starColoring(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "starColoring" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::starColoring"
// cWrapperName: "casadi__Sparsity__starColoring__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__starColoring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->starColoring(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__starColoring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__starColoring__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = obj->starColoring(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "starColoring2" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::starColoring2"
// cWrapperName: "casadi__Sparsity__starColoring2__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__starColoring2__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->starColoring2()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__starColoring2__0(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__starColoring2__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->starColoring2();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "starColoring2" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::starColoring2"
// cWrapperName: "casadi__Sparsity__starColoring2__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__starColoring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0)"
// call: "obj->starColoring2(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__starColoring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0);
casadi::Sparsity* casadi__Sparsity__starColoring2__1(std::string ** err_msg, casadi::Sparsity* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = obj->starColoring2(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "starColoring2" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::starColoring2"
// cWrapperName: "casadi__Sparsity__starColoring2__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__starColoring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1)"
// call: "obj->starColoring2(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__starColoring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__starColoring2__2(std::string ** err_msg, casadi::Sparsity* obj, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = obj->starColoring2(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "stronglyConnectedComponents" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::stronglyConnectedComponents"
// cWrapperName: "casadi__Sparsity__stronglyConnectedComponents"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__Sparsity__stronglyConnectedComponents(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->stronglyConnectedComponents(x0_, x1_)"
// params: [Ref (StdVec CInt),Ref (StdVec CInt)]
extern "C"
    int casadi__Sparsity__stronglyConnectedComponents(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
int casadi__Sparsity__stronglyConnectedComponents(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

        int ret = obj->stronglyConnectedComponents(x0_, x1_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "sub" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::sub"
// cWrapperName: "casadi__Sparsity__sub"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__sub(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->sub(x0_, x1_, x2_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__sub(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
casadi::Sparsity* casadi__Sparsity__sub(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::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::Sparsity ret = obj->sub(x0_, x1_, x2_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "transpose" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::transpose"
// cWrapperName: "casadi__Sparsity__transpose__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->transpose(x0_)"
// params: [Ref (StdVec CInt)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0);
casadi::Sparsity* casadi__Sparsity__transpose__0(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

        casadi::Sparsity ret = obj->transpose(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "transpose" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::transpose"
// cWrapperName: "casadi__Sparsity__transpose__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1)"
// call: "obj->transpose(x0_, x1_)"
// params: [Ref (StdVec CInt),CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1);
casadi::Sparsity* casadi__Sparsity__transpose__1(std::string ** err_msg, casadi::Sparsity* obj, std::vector< int >* x0, int x1){
    try {
        std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::Sparsity ret = obj->transpose(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "transpose" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::transpose"
// cWrapperName: "casadi__Sparsity__transpose__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__transpose__2(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->transpose()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__transpose__2(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__transpose__2(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->transpose();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "tril" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::tril"
// cWrapperName: "casadi__Sparsity__tril"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__tril(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity::tril(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__tril(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__tril(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::tril(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "triplet" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::triplet"
// cWrapperName: "casadi__Sparsity__triplet__0"
// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "casadi::Sparsity::triplet(x0_, x1_, x2_, x3_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
casadi::Sparsity* casadi__Sparsity__triplet__0(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "triplet" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::triplet"
// cWrapperName: "casadi__Sparsity__triplet__1"
// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
// call: "casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt)]
extern "C"
    casadi::Sparsity* casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4);
casadi::Sparsity* casadi__Sparsity__triplet__1(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);

        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "triplet" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::triplet"
// cWrapperName: "casadi__Sparsity__triplet__2"
// protoArgs: "(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5)"
// call: "casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_)"
// params: [CInt,CInt,Ref (Const (StdVec CInt)),Ref (Const (StdVec CInt)),Ref (StdVec CInt),CBool]
extern "C"
    casadi::Sparsity* casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5);
casadi::Sparsity* casadi__Sparsity__triplet__2(std::string ** err_msg, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);
        std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);
        std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);
        bool x5_ = Marshaling<bool,int>::marshal(x5);

        casadi::Sparsity ret = casadi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "triu" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::triu"
// cWrapperName: "casadi__Sparsity__triu"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__triu(std::string ** err_msg, int x0)"
// call: "casadi::Sparsity::triu(x0_)"
// params: [CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__triu(std::string ** err_msg, int x0);
casadi::Sparsity* casadi__Sparsity__triu(std::string ** err_msg, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::Sparsity ret = casadi::Sparsity::triu(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "unidirectionalColoring" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::unidirectionalColoring"
// cWrapperName: "casadi__Sparsity__unidirectionalColoring__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__0(std::string ** err_msg, casadi::Sparsity* obj)"
// call: "obj->unidirectionalColoring()"
// params: []
extern "C"
    casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__0(std::string ** err_msg, casadi::Sparsity* obj);
casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__0(std::string ** err_msg, casadi::Sparsity* obj){
    try {

        casadi::Sparsity ret = obj->unidirectionalColoring();
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "unidirectionalColoring" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::unidirectionalColoring"
// cWrapperName: "casadi__Sparsity__unidirectionalColoring__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->unidirectionalColoring(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__1(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::Sparsity ret = obj->unidirectionalColoring(x0_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "unidirectionalColoring" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::unidirectionalColoring"
// cWrapperName: "casadi__Sparsity__unidirectionalColoring__2"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1)"
// call: "obj->unidirectionalColoring(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1);
casadi::Sparsity* casadi__Sparsity__unidirectionalColoring__2(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = obj->unidirectionalColoring(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "unit" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::unit"
// cWrapperName: "casadi__Sparsity__unit"
// protoArgs: "(std::string ** err_msg, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Sparsity")
// cWrapperRetType: "casadi::Sparsity*"
// proto: "casadi::Sparsity* casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1)"
// call: "casadi::Sparsity::unit(x0_, x1_)"
// params: [CInt,CInt]
extern "C"
    casadi::Sparsity* casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1);
casadi::Sparsity* casadi__Sparsity__unit(std::string ** err_msg, int x0, int x1){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::Sparsity ret = casadi::Sparsity::unit(x0_, x1_);
        return WrapReturn< casadi::Sparsity*, casadi::Sparsity >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "StabilizedQPSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "StabilizedQPSolver")
extern "C"
    void delete_casadi__StabilizedQPSolver(casadi::StabilizedQPSolver* obj);
void delete_casadi__StabilizedQPSolver(casadi::StabilizedQPSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::StabilizedQPSolver"
// cppName: "casadi::StabilizedQPSolver"
// cWrapperName: "casadi__StabilizedQPSolver__CONSTRUCTOR"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "StabilizedQPSolver")
// cWrapperRetType: "casadi::StabilizedQPSolver*"
// proto: "casadi::StabilizedQPSolver* casadi__StabilizedQPSolver__CONSTRUCTOR(std::string ** err_msg)"
// call: "casadi::StabilizedQPSolver()"
// params: []
extern "C"
    casadi::StabilizedQPSolver* casadi__StabilizedQPSolver__CONSTRUCTOR(std::string ** err_msg);
casadi::StabilizedQPSolver* casadi__StabilizedQPSolver__CONSTRUCTOR(std::string ** err_msg){
    try {

        casadi::StabilizedQPSolver ret = casadi::StabilizedQPSolver();
        return WrapReturn< casadi::StabilizedQPSolver*, casadi::StabilizedQPSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "generateNativeCode" ===============
// class: "casadi::StabilizedQPSolver"
// cppName: "casadi::StabilizedQPSolver::generateNativeCode"
// cWrapperName: "casadi__StabilizedQPSolver__generateNativeCode"
// protoArgs: "(std::string ** err_msg, casadi::StabilizedQPSolver* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__StabilizedQPSolver__generateNativeCode(std::string ** err_msg, casadi::StabilizedQPSolver* obj, std::string* x0)"
// call: "obj->generateNativeCode(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__StabilizedQPSolver__generateNativeCode(std::string ** err_msg, casadi::StabilizedQPSolver* obj, std::string* x0);
void casadi__StabilizedQPSolver__generateNativeCode(std::string ** err_msg, casadi::StabilizedQPSolver* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->generateNativeCode(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setLPOptions" ===============
// class: "casadi::StabilizedQPSolver"
// cppName: "casadi::StabilizedQPSolver::setLPOptions"
// cWrapperName: "casadi__StabilizedQPSolver__setLPOptions"
// protoArgs: "(std::string ** err_msg, casadi::StabilizedQPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__StabilizedQPSolver__setLPOptions(std::string ** err_msg, casadi::StabilizedQPSolver* obj)"
// call: "obj->setLPOptions()"
// params: []
extern "C"
    void casadi__StabilizedQPSolver__setLPOptions(std::string ** err_msg, casadi::StabilizedQPSolver* obj);
void casadi__StabilizedQPSolver__setLPOptions(std::string ** err_msg, casadi::StabilizedQPSolver* obj){
    try {

    obj->setLPOptions();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}



// ================== delete UserType (Namespace ["casadi"]) (Name "SymbolicQR")===============
// classType: UserType (Namespace ["casadi"]) (Name "SymbolicQR")
extern "C"
    void delete_casadi__SymbolicQR(casadi::SymbolicQR* obj);
void delete_casadi__SymbolicQR(casadi::SymbolicQR* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SymbolicQR"
// cppName: "casadi::SymbolicQR"
// cWrapperName: "casadi__SymbolicQR__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SymbolicQR")
// cWrapperRetType: "casadi::SymbolicQR*"
// proto: "casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__0(std::string ** err_msg, casadi::Sparsity* x0)"
// call: "casadi::SymbolicQR(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__0(std::string ** err_msg, casadi::Sparsity* x0);
casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__0(std::string ** err_msg, casadi::Sparsity* x0){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);

        casadi::SymbolicQR ret = casadi::SymbolicQR(x0_);
        return WrapReturn< casadi::SymbolicQR*, casadi::SymbolicQR >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SymbolicQR"
// cppName: "casadi::SymbolicQR"
// cWrapperName: "casadi__SymbolicQR__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SymbolicQR")
// cWrapperRetType: "casadi::SymbolicQR*"
// proto: "casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__1(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// call: "casadi::SymbolicQR(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__1(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__1(std::string ** err_msg, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::SymbolicQR ret = casadi::SymbolicQR(x0_, x1_);
        return WrapReturn< casadi::SymbolicQR*, casadi::SymbolicQR >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::SymbolicQR"
// cppName: "casadi::SymbolicQR"
// cWrapperName: "casadi__SymbolicQR__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "SymbolicQR")
// cWrapperRetType: "casadi::SymbolicQR*"
// proto: "casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__2(std::string ** err_msg)"
// call: "casadi::SymbolicQR()"
// params: []
extern "C"
    casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__2(std::string ** err_msg);
casadi::SymbolicQR* casadi__SymbolicQR__CONSTRUCTOR__2(std::string ** err_msg){
    try {

        casadi::SymbolicQR ret = casadi::SymbolicQR();
        return WrapReturn< casadi::SymbolicQR*, casadi::SymbolicQR >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "creator" ===============
// class: "casadi::SymbolicQR"
// cppName: "casadi::SymbolicQR::creator"
// cWrapperName: "casadi__SymbolicQR__creator"
// protoArgs: "(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
// cWrapperRetType: "casadi::LinearSolver*"
// proto: "casadi::LinearSolver* casadi__SymbolicQR__creator(std::string ** err_msg, casadi::Sparsity* x0, int x1)"
// call: "casadi::SymbolicQR::creator(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity"))),CInt]
extern "C"
    casadi::LinearSolver* casadi__SymbolicQR__creator(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::LinearSolver* casadi__SymbolicQR__creator(std::string ** err_msg, casadi::Sparsity* x0, int x1){
    try {
        casadi::Sparsity x0_ = Marshaling<casadi::Sparsity,casadi::Sparsity*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

        casadi::LinearSolver ret = casadi::SymbolicQR::creator(x0_, x1_);
        return WrapReturn< casadi::LinearSolver*, casadi::LinearSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}



// ================== delete IOInterface (UserType (Namespace ["casadi"]) (Name "Function"))===============
// classType: IOInterface (UserType (Namespace ["casadi"]) (Name "Function"))
extern "C"
    void delete_casadi__IOInterface_casadi__Function_(casadi::IOInterface< casadi::Function* >* obj);
void delete_casadi__IOInterface_casadi__Function_(casadi::IOInterface< casadi::Function* >* obj){
    delete obj;
}

// ================== Normal method: "getInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___getInput__0"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->getInput(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::DMatrix ret = obj->getInput(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___getInput__1"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->getInput()"
// params: []
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::DMatrix ret = obj->getInput();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___getInput__2"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->getInput(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___getInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::DMatrix ret = obj->getInput(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getInputScheme" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getInputScheme"
// cWrapperName: "casadi__IOInterface_casadi__Function___getInputScheme"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOInterface_casadi__Function___getInputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->getInputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__IOInterface_casadi__Function___getInputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::IOScheme* casadi__IOInterface_casadi__Function___getInputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::IOScheme ret = obj->getInputScheme();
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNumInputs" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getNumInputs"
// cWrapperName: "casadi__IOInterface_casadi__Function___getNumInputs"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOInterface_casadi__Function___getNumInputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->getNumInputs()"
// params: []
extern "C"
    int casadi__IOInterface_casadi__Function___getNumInputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
int casadi__IOInterface_casadi__Function___getNumInputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        int ret = obj->getNumInputs();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getNumOutputs" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getNumOutputs"
// cWrapperName: "casadi__IOInterface_casadi__Function___getNumOutputs"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOInterface_casadi__Function___getNumOutputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->getNumOutputs()"
// params: []
extern "C"
    int casadi__IOInterface_casadi__Function___getNumOutputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
int casadi__IOInterface_casadi__Function___getNumOutputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        int ret = obj->getNumOutputs();
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___getOutput__0"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->getOutput(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::DMatrix ret = obj->getOutput(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___getOutput__1"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->getOutput()"
// params: []
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::DMatrix ret = obj->getOutput();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___getOutput__2"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->getOutput(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___getOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::DMatrix ret = obj->getOutput(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "getOutputScheme" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::getOutputScheme"
// cWrapperName: "casadi__IOInterface_casadi__Function___getOutputScheme"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "IOScheme")
// cWrapperRetType: "casadi::IOScheme*"
// proto: "casadi::IOScheme* casadi__IOInterface_casadi__Function___getOutputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->getOutputScheme()"
// params: []
extern "C"
    casadi::IOScheme* casadi__IOInterface_casadi__Function___getOutputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::IOScheme* casadi__IOInterface_casadi__Function___getOutputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::IOScheme ret = obj->getOutputScheme();
        return WrapReturn< casadi::IOScheme*, casadi::IOScheme >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "input" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::input"
// cWrapperName: "casadi__IOInterface_casadi__Function___input__0"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___input__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->input(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___input__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___input__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::DMatrix ret = obj->input(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "input" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::input"
// cWrapperName: "casadi__IOInterface_casadi__Function___input__1"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___input__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->input()"
// params: []
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___input__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::DMatrix* casadi__IOInterface_casadi__Function___input__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::DMatrix ret = obj->input();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "input" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::input"
// cWrapperName: "casadi__IOInterface_casadi__Function___input__2"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___input__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->input(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___input__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___input__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::DMatrix ret = obj->input(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "input" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::input"
// cWrapperName: "casadi__IOInterface_casadi__Function___input__3"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___input__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->input(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___input__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___input__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::DMatrix ret = obj->input(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "input" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::input"
// cWrapperName: "casadi__IOInterface_casadi__Function___input__4"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___input__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->input()"
// params: []
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___input__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::DMatrix* casadi__IOInterface_casadi__Function___input__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::DMatrix ret = obj->input();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "input" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::input"
// cWrapperName: "casadi__IOInterface_casadi__Function___input__5"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___input__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->input(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___input__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___input__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::DMatrix ret = obj->input(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "inputSchemeEntry" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::inputSchemeEntry"
// cWrapperName: "casadi__IOInterface_casadi__Function___inputSchemeEntry"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOInterface_casadi__Function___inputSchemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->inputSchemeEntry(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__IOInterface_casadi__Function___inputSchemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
int casadi__IOInterface_casadi__Function___inputSchemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        int ret = obj->inputSchemeEntry(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "output" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::output"
// cWrapperName: "casadi__IOInterface_casadi__Function___output__0"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___output__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->output(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___output__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___output__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::DMatrix ret = obj->output(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "output" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::output"
// cWrapperName: "casadi__IOInterface_casadi__Function___output__1"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___output__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->output()"
// params: []
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___output__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::DMatrix* casadi__IOInterface_casadi__Function___output__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::DMatrix ret = obj->output();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "output" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::output"
// cWrapperName: "casadi__IOInterface_casadi__Function___output__2"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix")
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___output__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->output(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___output__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___output__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::DMatrix ret = obj->output(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "output" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::output"
// cWrapperName: "casadi__IOInterface_casadi__Function___output__3"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___output__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->output(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___output__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___output__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        casadi::DMatrix ret = obj->output(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "output" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::output"
// cWrapperName: "casadi__IOInterface_casadi__Function___output__4"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// args: "()"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___output__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj)"
// call: "obj->output()"
// params: []
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___output__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj);
casadi::DMatrix* casadi__IOInterface_casadi__Function___output__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj){
    try {

        casadi::DMatrix ret = obj->output();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "output" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::output"
// cWrapperName: "casadi__IOInterface_casadi__Function___output__5"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))
// cWrapperRetType: "casadi::DMatrix*"
// proto: "casadi::DMatrix* casadi__IOInterface_casadi__Function___output__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->output(x0_)"
// params: [CInt]
extern "C"
    casadi::DMatrix* casadi__IOInterface_casadi__Function___output__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
casadi::DMatrix* casadi__IOInterface_casadi__Function___output__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

        casadi::DMatrix ret = obj->output(x0_);
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "outputSchemeEntry" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::outputSchemeEntry"
// cWrapperName: "casadi__IOInterface_casadi__Function___outputSchemeEntry"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOInterface_casadi__Function___outputSchemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0)"
// call: "obj->outputSchemeEntry(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    int casadi__IOInterface_casadi__Function___outputSchemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0);
int casadi__IOInterface_casadi__Function___outputSchemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        int ret = obj->outputSchemeEntry(x0_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "schemeEntry" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::schemeEntry"
// cWrapperName: "casadi__IOInterface_casadi__Function___schemeEntry"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IOInterface_casadi__Function___schemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0, std::string* x1, int x2)"
// call: "obj->schemeEntry(x0_, x1_, x2_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IOScheme"))),Ref (Const StdString),CBool]
extern "C"
    int casadi__IOInterface_casadi__Function___schemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0, std::string* x1, int x2);
int casadi__IOInterface_casadi__Function___schemeEntry(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0, std::string* x1, int x2){
    try {
        casadi::IOScheme x0_ = Marshaling<casadi::IOScheme,casadi::IOScheme*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        int ret = obj->schemeEntry(x0_, x1_, x2_);
        return WrapReturn< int, int >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__0"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1);
void casadi__IOInterface_casadi__Function___setInput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    obj->setInput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__1"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
// call: "obj->setInput(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0);
void casadi__IOInterface_casadi__Function___setInput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

    obj->setInput(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__2"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1);
void casadi__IOInterface_casadi__Function___setInput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setInput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__3"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
// params: [Ref (Const (StdVec CDouble)),Ref (Const StdString)]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1);
void casadi__IOInterface_casadi__Function___setInput__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    obj->setInput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__4"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0)"
// call: "obj->setInput(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0);
void casadi__IOInterface_casadi__Function___setInput__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setInput(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__5"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
// params: [Ref (Const (StdVec CDouble)),CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1);
void casadi__IOInterface_casadi__Function___setInput__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setInput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__6"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__6(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
// params: [CDouble,Ref (Const StdString)]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__6(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1);
void casadi__IOInterface_casadi__Function___setInput__6(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    obj->setInput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__7"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__7(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0)"
// call: "obj->setInput(x0_)"
// params: [CDouble]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__7(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0);
void casadi__IOInterface_casadi__Function___setInput__7(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->setInput(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInput__8"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInput__8(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
// params: [CDouble,CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setInput__8(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1);
void casadi__IOInterface_casadi__Function___setInput__8(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setInput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setInputScheme" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setInputScheme"
// cWrapperName: "casadi__IOInterface_casadi__Function___setInputScheme"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setInputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0)"
// call: "obj->setInputScheme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IOScheme")))]
extern "C"
    void casadi__IOInterface_casadi__Function___setInputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0);
void casadi__IOInterface_casadi__Function___setInputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0){
    try {
        casadi::IOScheme x0_ = Marshaling<casadi::IOScheme,casadi::IOScheme*>::marshal(x0);

    obj->setInputScheme(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNumInputs" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setNumInputs"
// cWrapperName: "casadi__IOInterface_casadi__Function___setNumInputs"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setNumInputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->setNumInputs(x0_)"
// params: [CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setNumInputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
void casadi__IOInterface_casadi__Function___setNumInputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setNumInputs(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setNumOutputs" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setNumOutputs"
// cWrapperName: "casadi__IOInterface_casadi__Function___setNumOutputs"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setNumOutputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0)"
// call: "obj->setNumOutputs(x0_)"
// params: [CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setNumOutputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0);
void casadi__IOInterface_casadi__Function___setNumOutputs(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, int x0){
    try {
        int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setNumOutputs(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__0"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const StdString)]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1);
void casadi__IOInterface_casadi__Function___setOutput__0(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, std::string* x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    obj->setOutput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__1"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0)"
// call: "obj->setOutput(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0);
void casadi__IOInterface_casadi__Function___setOutput__1(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);

    obj->setOutput(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__2"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1);
void casadi__IOInterface_casadi__Function___setOutput__2(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::DMatrix* x0, int x1){
    try {
        casadi::DMatrix x0_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOutput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__3"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
// params: [Ref (Const (StdVec CDouble)),Ref (Const StdString)]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1);
void casadi__IOInterface_casadi__Function___setOutput__3(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, std::string* x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    obj->setOutput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__4"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0)"
// call: "obj->setOutput(x0_)"
// params: [Ref (Const (StdVec CDouble))]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0);
void casadi__IOInterface_casadi__Function___setOutput__4(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setOutput(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__5"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
// params: [Ref (Const (StdVec CDouble)),CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1);
void casadi__IOInterface_casadi__Function___setOutput__5(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, std::vector< double >* x0, int x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOutput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__6"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__6(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
// params: [CDouble,Ref (Const StdString)]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__6(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1);
void casadi__IOInterface_casadi__Function___setOutput__6(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, std::string* x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    obj->setOutput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__7"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__7(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0)"
// call: "obj->setOutput(x0_)"
// params: [CDouble]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__7(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0);
void casadi__IOInterface_casadi__Function___setOutput__7(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

    obj->setOutput(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutput" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutput"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutput__8"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutput__8(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
// params: [CDouble,CInt]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutput__8(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1);
void casadi__IOInterface_casadi__Function___setOutput__8(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, double x0, int x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOutput(x0_, x1_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "setOutputScheme" ===============
// class: "casadi::IOInterface< casadi::Function >"
// cppName: "casadi::IOInterface< casadi::Function >::setOutputScheme"
// cWrapperName: "casadi__IOInterface_casadi__Function___setOutputScheme"
// protoArgs: "(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__IOInterface_casadi__Function___setOutputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0)"
// call: "obj->setOutputScheme(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IOScheme")))]
extern "C"
    void casadi__IOInterface_casadi__Function___setOutputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0);
void casadi__IOInterface_casadi__Function___setOutputScheme(std::string ** err_msg, casadi::IOInterface< casadi::Function >* obj, casadi::IOScheme* x0){
    try {
        casadi::IOScheme x0_ = Marshaling<casadi::IOScheme,casadi::IOScheme*>::marshal(x0);

    obj->setOutputScheme(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}