casadi-bindings-core-2.1.3.0: 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/cle_solver.hpp"
#include "casadi/core/function/control_simulator.hpp"
#include "casadi/core/function/custom_function.hpp"
#include "casadi/core/function/dle_solver.hpp"
#include "casadi/core/function/dple_solver.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/lr_dle_solver.hpp"
#include "casadi/core/function/lr_dple_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/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/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/misc/integration_tools.hpp"
#include "casadi/core/misc/symbolic_nlp.hpp"
#include "casadi/core/misc/symbolic_ocp.hpp"
#include "casadi/core/misc/variable.hpp"
#include "casadi/core/misc/xml_file.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: "getPlugins" ===============
// class: "casadi::CasadiMeta"
// cppName: "casadi::CasadiMeta::getPlugins"
// cWrapperName: "casadi__CasadiMeta__getPlugins"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__CasadiMeta__getPlugins(std::string ** err_msg)"
// call: "casadi::CasadiMeta::getPlugins()"
// params: []
extern "C"
    std::string* casadi__CasadiMeta__getPlugins(std::string ** err_msg);
std::string* casadi__CasadiMeta__getPlugins(std::string ** err_msg){
    try {

        std::string ret = casadi::CasadiMeta::getPlugins();
        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: "getCatchErrorsSwig" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::getCatchErrorsSwig"
// cWrapperName: "casadi__CasadiOptions__getCatchErrorsSwig"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int casadi__CasadiOptions__getCatchErrorsSwig(std::string ** err_msg)"
// call: "casadi::CasadiOptions::getCatchErrorsSwig()"
// params: []
extern "C"
    int casadi__CasadiOptions__getCatchErrorsSwig(std::string ** err_msg);
int casadi__CasadiOptions__getCatchErrorsSwig(std::string ** err_msg){
    try {

        bool ret = casadi::CasadiOptions::getCatchErrorsSwig();
        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: "setCatchErrorsSwig" ===============
// class: "casadi::CasadiOptions"
// cppName: "casadi::CasadiOptions::setCatchErrorsSwig"
// cWrapperName: "casadi__CasadiOptions__setCatchErrorsSwig"
// protoArgs: "(std::string ** err_msg, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__CasadiOptions__setCatchErrorsSwig(std::string ** err_msg, int x0)"
// call: "casadi::CasadiOptions::setCatchErrorsSwig(x0_)"
// params: [CBool]
extern "C"
    void casadi__CasadiOptions__setCatchErrorsSwig(std::string ** err_msg, int x0);
void casadi__CasadiOptions__setCatchErrorsSwig(std::string ** err_msg, int x0){
    try {
        bool x0_ = Marshaling<bool,int>::marshal(x0);

    casadi::CasadiOptions::setCatchErrorsSwig(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 "CleSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "CleSolver")
extern "C"
    void delete_casadi__CleSolver(casadi::CleSolver* obj);
void delete_casadi__CleSolver(casadi::CleSolver* obj){
    delete obj;
}

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

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


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

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


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

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


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

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


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

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


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

    obj->printStats();
    } 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____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____ge____0(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____0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____ge____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->__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: "__ge__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__ge__"
// cWrapperName: "casadi__DMatrix____ge____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____ge____1(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____1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____ge____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->__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____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____gt____0(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____0(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____gt____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->__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: "__gt__" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::__gt__"
// cWrapperName: "casadi__DMatrix____gt____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____gt____1(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____1(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0);
casadi::DMatrix* casadi__DMatrix____gt____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->__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, std::vector< double >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// 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, std::vector< double >* x3)"
// call: "casadi::DMatrix::mul_no_alloc_nn(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix"))),Ref (UserType (Namespace ["casadi"]) (Name "DMatrix")),Ref (StdVec CDouble)]
extern "C"
    void casadi__DMatrix__mul_no_alloc_nn__1(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::DMatrix* x2, std::vector< double >* x3);
void casadi__DMatrix__mul_no_alloc_nn__1(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::DMatrix* x2, std::vector< double >* x3){
    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);
        std::vector< double > x3_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x3);

    casadi::DMatrix::mul_no_alloc_nn(x0_, x1_, x2_, x3_);
    } 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__2"
// 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__2(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__2(std::string ** err_msg, casadi::DMatrix* x0, casadi::DMatrix* x1, casadi::DMatrix* x2);
void casadi__DMatrix__mul_no_alloc_nn__2(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, std::vector< double >* x0, casadi::DMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__DMatrix__quad_form(std::string ** err_msg, std::vector< double >* x0, casadi::DMatrix* x1)"
// call: "casadi::DMatrix::quad_form(x0_, x1_)"
// params: [Ref (Const (StdVec CDouble)),Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))]
extern "C"
    double casadi__DMatrix__quad_form(std::string ** err_msg, std::vector< double >* x0, casadi::DMatrix* x1);
double casadi__DMatrix__quad_form(std::string ** err_msg, std::vector< double >* x0, casadi::DMatrix* x1){
    try {
        std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
        casadi::DMatrix x1_ = Marshaling<casadi::DMatrix,casadi::DMatrix*>::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;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getRepresentation"
// cWrapperName: "casadi__DMatrix__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__DMatrix__getRepresentation(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__DMatrix__getRepresentation(std::string ** err_msg, casadi::DMatrix* obj);
std::string* casadi__DMatrix__getRepresentation(std::string ** err_msg, casadi::DMatrix* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::DMatrix"
// cppName: "casadi::DMatrix::getDescription"
// cWrapperName: "casadi__DMatrix__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__DMatrix__getDescription(std::string ** err_msg, casadi::DMatrix* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__DMatrix__getDescription(std::string ** err_msg, casadi::DMatrix* obj);
std::string* casadi__DMatrix__getDescription(std::string ** err_msg, casadi::DMatrix* 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;
    }
}



// ================== 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 "DleSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "DleSolver")
extern "C"
    void delete_casadi__DleSolver(casadi::DleSolver* obj);
void delete_casadi__DleSolver(casadi::DleSolver* obj){
    delete obj;
}

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

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


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

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


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

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


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

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


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

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


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

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



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

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


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

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


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

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


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

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


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

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


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

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


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

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



// ================== 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: "generateCode" ===============
// class: "casadi::Function"
// cppName: "casadi::Function::generateCode"
// cWrapperName: "casadi__Function__generateCode__2"
// protoArgs: "(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Function__generateCode__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1)"
// call: "obj->generateCode(x0_, x1_)"
// params: [Ref (Const StdString),CBool]
extern "C"
    void casadi__Function__generateCode__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1);
void casadi__Function__generateCode__2(std::string ** err_msg, casadi::Function* obj, std::string* x0, int x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

    obj->generateCode(x0_, x1_);
    } 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;
    }
}


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

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


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

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


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

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



// ================== 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____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____ge____0(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____0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____ge____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->__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: "__ge__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__ge__"
// cWrapperName: "casadi__IMatrix____ge____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____ge____1(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____1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____ge____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->__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____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____gt____0(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____0(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____gt____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->__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: "__gt__" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::__gt__"
// cWrapperName: "casadi__IMatrix____gt____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____gt____1(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____1(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0);
casadi::IMatrix* casadi__IMatrix____gt____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->__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, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// 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, std::vector< int >* x3)"
// call: "casadi::IMatrix::mul_no_alloc_nn(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix"))),Ref (UserType (Namespace ["casadi"]) (Name "IMatrix")),Ref (StdVec CInt)]
extern "C"
    void casadi__IMatrix__mul_no_alloc_nn__1(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2, std::vector< int >* x3);
void casadi__IMatrix__mul_no_alloc_nn__1(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2, std::vector< int >* x3){
    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);
        std::vector< int > x3_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x3);

    casadi::IMatrix::mul_no_alloc_nn(x0_, x1_, x2_, x3_);
    } 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__2"
// 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__2(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__2(std::string ** err_msg, casadi::IMatrix* x0, casadi::IMatrix* x1, casadi::IMatrix* x2);
void casadi__IMatrix__mul_no_alloc_nn__2(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, std::vector< int >* x0, casadi::IMatrix* x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int casadi__IMatrix__quad_form(std::string ** err_msg, std::vector< int >* x0, casadi::IMatrix* x1)"
// call: "casadi::IMatrix::quad_form(x0_, x1_)"
// params: [Ref (Const (StdVec CInt)),Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))]
extern "C"
    int casadi__IMatrix__quad_form(std::string ** err_msg, std::vector< int >* x0, casadi::IMatrix* x1);
int casadi__IMatrix__quad_form(std::string ** err_msg, 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);

        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;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getRepresentation"
// cWrapperName: "casadi__IMatrix__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IMatrix__getRepresentation(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__IMatrix__getRepresentation(std::string ** err_msg, casadi::IMatrix* obj);
std::string* casadi__IMatrix__getRepresentation(std::string ** err_msg, casadi::IMatrix* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::IMatrix"
// cppName: "casadi::IMatrix::getDescription"
// cWrapperName: "casadi__IMatrix__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__IMatrix__getDescription(std::string ** err_msg, casadi::IMatrix* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__IMatrix__getDescription(std::string ** err_msg, casadi::IMatrix* obj);
std::string* casadi__IMatrix__getDescription(std::string ** err_msg, casadi::IMatrix* 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;
    }
}



// ================== 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;
}

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

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


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

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


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

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


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

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


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

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


// ================== 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;
    }
}


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

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


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

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



// ================== 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__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
// cWrapperRetType: "casadi::Integrator*"
// proto: "casadi::Integrator* casadi__Integrator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1)"
// call: "casadi::Integrator(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    casadi::Integrator* casadi__Integrator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1);
casadi::Integrator* casadi__Integrator__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);

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


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

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::Integrator"
// cppName: "casadi::Integrator"
// cWrapperName: "casadi__Integrator__CONSTRUCTOR__2"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "Integrator")
// cWrapperRetType: "casadi::Integrator*"
// proto: "casadi::Integrator* casadi__Integrator__CONSTRUCTOR__2(std::string ** err_msg)"
// call: "casadi::Integrator()"
// params: []
extern "C"
    casadi::Integrator* casadi__Integrator__CONSTRUCTOR__2(std::string ** err_msg);
casadi::Integrator* casadi__Integrator__CONSTRUCTOR__2(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;
    }
}


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

        std::string ret = casadi::Integrator::doc(x0_);
        return WrapReturn< std::string*, std::string >::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;
    }
}


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

        bool ret = casadi::Integrator::hasPlugin(x0_);
        return WrapReturn< int, bool >::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;
    }
}


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

    casadi::Integrator::loadPlugin(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;
    }
}


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

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



// ================== 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, std::string* x0, casadi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "LinearSolver")
// cWrapperRetType: "casadi::LinearSolver*"
// proto: "casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1)"
// call: "casadi::LinearSolver(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Sparsity* x1);
casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__0(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::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;
    }
}


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

        casadi::LinearSolver ret = casadi::LinearSolver(x0_, x1_, x2_);
        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__2"
// 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__2(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__2(std::string ** err_msg, casadi::Sparsity* x0);
casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__2(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__3"
// 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__3(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__3(std::string ** err_msg, casadi::Sparsity* x0, int x1);
casadi::LinearSolver* casadi__LinearSolver__CONSTRUCTOR__3(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;
    }
}


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

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


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

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


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

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


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

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


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

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


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

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


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

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


// ================== 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 "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;
    }
}


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

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


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

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


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

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



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

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

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


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

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


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

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


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

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


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

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


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

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



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

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

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


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

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


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

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


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

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


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

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


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

    obj->printStats();
    } 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__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, casadi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
// cWrapperRetType: "casadi::NlpSolver*"
// proto: "casadi::NlpSolver* casadi__NlpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1)"
// call: "casadi::NlpSolver(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const (UserType (Namespace ["casadi"]) (Name "Function")))]
extern "C"
    casadi::NlpSolver* casadi__NlpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1);
casadi::NlpSolver* casadi__NlpSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, casadi::Function* x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        casadi::Function x1_ = Marshaling<casadi::Function,casadi::Function*>::marshal(x1);

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


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::NlpSolver"
// cppName: "casadi::NlpSolver"
// cWrapperName: "casadi__NlpSolver__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "NlpSolver")
// cWrapperRetType: "casadi::NlpSolver*"
// proto: "casadi::NlpSolver* casadi__NlpSolver__CONSTRUCTOR__1(std::string ** err_msg)"
// call: "casadi::NlpSolver()"
// params: []
extern "C"
    casadi::NlpSolver* casadi__NlpSolver__CONSTRUCTOR__1(std::string ** err_msg);
casadi::NlpSolver* casadi__NlpSolver__CONSTRUCTOR__1(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;
    }
}


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

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


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

        casadi::DMatrix ret = obj->getReducedHessian();
        return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::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;
    }
}


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

        bool ret = casadi::NlpSolver::hasPlugin(x0_);
        return WrapReturn< int, bool >::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;
    }
}


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

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


// ================== 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: "setOptionsFromFile" ===============
// class: "casadi::NlpSolver"
// cppName: "casadi::NlpSolver::setOptionsFromFile"
// cWrapperName: "casadi__NlpSolver__setOptionsFromFile"
// protoArgs: "(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__NlpSolver__setOptionsFromFile(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0)"
// call: "obj->setOptionsFromFile(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__NlpSolver__setOptionsFromFile(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0);
void casadi__NlpSolver__setOptionsFromFile(std::string ** err_msg, casadi::NlpSolver* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    obj->setOptionsFromFile(x0_);
    } 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 "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 "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;
    }
}


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

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


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

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


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

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


// ================== 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;
    }
}


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

        std::string ret = casadi::QpSolver::doc(x0_);
        return WrapReturn< std::string*, std::string >::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;
    }
}


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

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


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

    casadi::QpSolver::loadPlugin(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 "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____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____ge____0(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____0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____ge____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->__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: "__ge__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__ge__"
// cWrapperName: "casadi__SX____ge____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____ge____1(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____1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____ge____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->__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____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____gt____0(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____0(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____gt____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->__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: "__gt__" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::__gt__"
// cWrapperName: "casadi__SX____gt____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____gt____1(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____1(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0);
casadi::SX* casadi__SX____gt____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->__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, std::vector< casadi::SXElement* >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// 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, std::vector< casadi::SXElement* >* x3)"
// call: "casadi::SX::mul_no_alloc_nn(x0_, x1_, x2_, x3_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),Ref (UserType (Namespace ["casadi"]) (Name "SX")),Ref (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))]
extern "C"
    void casadi__SX__mul_no_alloc_nn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, std::vector< casadi::SXElement* >* x3);
void casadi__SX__mul_no_alloc_nn__1(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2, std::vector< casadi::SXElement* >* x3){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x1);
        casadi::SX x2_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x2);
        std::vector< casadi::SXElement > x3_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x3);

    casadi::SX::mul_no_alloc_nn(x0_, x1_, x2_, x3_);
    } 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__2"
// 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__2(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__2(std::string ** err_msg, casadi::SX* x0, casadi::SX* x1, casadi::SX* x2);
void casadi__SX__mul_no_alloc_nn__2(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, std::vector< casadi::SXElement* >* x0, casadi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__SX__quad_form(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, casadi::SX* x1)"
// call: "casadi::SX::quad_form(x0_, x1_)"
// params: [Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "SXElement")))),Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SXElement* casadi__SX__quad_form(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, casadi::SX* x1);
casadi::SXElement* casadi__SX__quad_form(std::string ** err_msg, std::vector< casadi::SXElement* >* x0, casadi::SX* x1){
    try {
        std::vector< casadi::SXElement > x0_ = Marshaling<std::vector< casadi::SXElement >,std::vector< casadi::SXElement* >*>::marshal(x0);
        casadi::SX x1_ = Marshaling<casadi::SX,casadi::SX*>::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;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getRepresentation"
// cWrapperName: "casadi__SX__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* obj);
std::string* casadi__SX__getRepresentation(std::string ** err_msg, casadi::SX* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::SX"
// cppName: "casadi::SX::getDescription"
// cWrapperName: "casadi__SX__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::SX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__SX__getDescription(std::string ** err_msg, casadi::SX* obj);
std::string* casadi__SX__getDescription(std::string ** err_msg, casadi::SX* 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;
    }
}



// ================== 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;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getRepresentation"
// cWrapperName: "casadi__SXElement__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SXElement__getRepresentation(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__SXElement__getRepresentation(std::string ** err_msg, casadi::SXElement* obj);
std::string* casadi__SXElement__getRepresentation(std::string ** err_msg, casadi::SXElement* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::SXElement"
// cppName: "casadi::SXElement::getDescription"
// cWrapperName: "casadi__SXElement__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SXElement__getDescription(std::string ** err_msg, casadi::SXElement* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__SXElement__getDescription(std::string ** err_msg, casadi::SXElement* obj);
std::string* casadi__SXElement__getDescription(std::string ** err_msg, casadi::SXElement* 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;
    }
}



// ================== 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 "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;
    }
}


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

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


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

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


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

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


// ================== 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;
    }
}


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

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


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

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


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

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


// ================== 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 "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: "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;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::getRepresentation"
// cWrapperName: "casadi__SharedObject__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* obj);
std::string* casadi__SharedObject__getRepresentation(std::string ** err_msg, casadi::SharedObject* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::SharedObject"
// cppName: "casadi::SharedObject::getDescription"
// cWrapperName: "casadi__SharedObject__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::SharedObject* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* obj);
std::string* casadi__SharedObject__getDescription(std::string ** err_msg, casadi::SharedObject* 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;
    }
}



// ================== 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;
    }
}


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice::getRepresentation"
// cWrapperName: "casadi__Slice__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::Slice* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* obj);
std::string* casadi__Slice__getRepresentation(std::string ** err_msg, casadi::Slice* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::Slice"
// cppName: "casadi::Slice::getDescription"
// cWrapperName: "casadi__Slice__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::Slice* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* obj);
std::string* casadi__Slice__getDescription(std::string ** err_msg, casadi::Slice* 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;
    }
}



// ================== 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;
    }
}


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

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


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

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


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

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



// ================== 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;
    }
}


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

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


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

        int ret = obj->bandwidthU();
        return WrapReturn< int, int >::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: "patternProductNew" ===============
// class: "casadi::Sparsity"
// cppName: "casadi::Sparsity::patternProductNew"
// cWrapperName: "casadi__Sparsity__patternProductNew"
// 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__patternProductNew(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0)"
// call: "obj->patternProductNew(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "Sparsity")))]
extern "C"
    casadi::Sparsity* casadi__Sparsity__patternProductNew(std::string ** err_msg, casadi::Sparsity* obj, casadi::Sparsity* x0);
casadi::Sparsity* casadi__Sparsity__patternProductNew(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->patternProductNew(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;
    }
}


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

        std::string ret = casadi::StabilizedQpSolver::doc(x0_);
        return WrapReturn< std::string*, std::string >::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;
    }
}


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

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


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

    casadi::StabilizedQpSolver::loadPlugin(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 "SymbolicNLP")===============
// classType: UserType (Namespace ["casadi"]) (Name "SymbolicNLP")
extern "C"
    void delete_casadi__SymbolicNLP(casadi::SymbolicNLP* obj);
void delete_casadi__SymbolicNLP(casadi::SymbolicNLP* obj){
    delete obj;
}

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

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


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::SymbolicNLP"
// cppName: "casadi::SymbolicNLP::getRepresentation"
// cWrapperName: "casadi__SymbolicNLP__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicNLP* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SymbolicNLP__getRepresentation(std::string ** err_msg, casadi::SymbolicNLP* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__SymbolicNLP__getRepresentation(std::string ** err_msg, casadi::SymbolicNLP* obj);
std::string* casadi__SymbolicNLP__getRepresentation(std::string ** err_msg, casadi::SymbolicNLP* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::SymbolicNLP"
// cppName: "casadi::SymbolicNLP::getDescription"
// cWrapperName: "casadi__SymbolicNLP__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicNLP* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SymbolicNLP__getDescription(std::string ** err_msg, casadi::SymbolicNLP* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__SymbolicNLP__getDescription(std::string ** err_msg, casadi::SymbolicNLP* obj);
std::string* casadi__SymbolicNLP__getDescription(std::string ** err_msg, casadi::SymbolicNLP* 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;
    }
}



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

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

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


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

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


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

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


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

        casadi::SX ret = obj->atTime(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: "atTime" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::atTime"
// cWrapperName: "casadi__SymbolicOCP__atTime__1"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SymbolicOCP__atTime__1(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// call: "obj->atTime(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CDouble,CBool]
extern "C"
    casadi::SX* casadi__SymbolicOCP__atTime__1(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2);
casadi::SX* casadi__SymbolicOCP__atTime__1(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::SX ret = obj->atTime(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: "atTime" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::atTime"
// cWrapperName: "casadi__SymbolicOCP__atTime__2"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SymbolicOCP__atTime__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1)"
// call: "obj->atTime(x0_, x1_)"
// params: [Ref (Const StdString),CDouble]
extern "C"
    casadi::SX* casadi__SymbolicOCP__atTime__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1);
casadi::SX* casadi__SymbolicOCP__atTime__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);

        casadi::SX ret = obj->atTime(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: "atTime" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::atTime"
// cWrapperName: "casadi__SymbolicOCP__atTime__3"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SymbolicOCP__atTime__3(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// call: "obj->atTime(x0_, x1_, x2_)"
// params: [Ref (Const StdString),CDouble,CBool]
extern "C"
    casadi::SX* casadi__SymbolicOCP__atTime__3(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2);
casadi::SX* casadi__SymbolicOCP__atTime__3(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, double x1, int x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        double x1_ = Marshaling<double,double>::marshal(x1);
        bool x2_ = Marshaling<bool,int>::marshal(x2);

        casadi::SX ret = obj->atTime(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: "beq" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::beq"
// cWrapperName: "casadi__SymbolicOCP__beq__0"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SX")
// cWrapperRetType: "casadi::SX*"
// proto: "casadi::SX* casadi__SymbolicOCP__beq__0(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0)"
// call: "obj->beq(x0_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))]
extern "C"
    casadi::SX* casadi__SymbolicOCP__beq__0(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0);
casadi::SX* casadi__SymbolicOCP__beq__0(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);

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


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

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


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

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


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

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


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

        std::vector< double > ret = obj->derivativeStart(x0_);
        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: "derivativeStart" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::derivativeStart"
// cWrapperName: "casadi__SymbolicOCP__derivativeStart__1"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* casadi__SymbolicOCP__derivativeStart__1(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1)"
// call: "obj->derivativeStart(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool]
extern "C"
    std::vector< double >* casadi__SymbolicOCP__derivativeStart__1(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1);
std::vector< double >* casadi__SymbolicOCP__derivativeStart__1(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        std::vector< double > ret = obj->derivativeStart(x0_, x1_);
        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: "derivativeStart" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::derivativeStart"
// cWrapperName: "casadi__SymbolicOCP__derivativeStart__2"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__SymbolicOCP__derivativeStart__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->derivativeStart(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    double casadi__SymbolicOCP__derivativeStart__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0);
double casadi__SymbolicOCP__derivativeStart__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

        std::vector< double > ret = obj->nominal(x0_);
        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: "nominal" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::nominal"
// cWrapperName: "casadi__SymbolicOCP__nominal__1"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__SymbolicOCP__nominal__1(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->nominal(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    double casadi__SymbolicOCP__nominal__1(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0);
double casadi__SymbolicOCP__nominal__1(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


// ================== Normal method: "setUnit" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::setUnit"
// cWrapperName: "casadi__SymbolicOCP__setUnit"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__SymbolicOCP__setUnit(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, std::string* x1)"
// call: "obj->setUnit(x0_, x1_)"
// params: [Ref (Const StdString),Ref (Const StdString)]
extern "C"
    void casadi__SymbolicOCP__setUnit(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0, std::string* x1);
void casadi__SymbolicOCP__setUnit(std::string ** err_msg, casadi::SymbolicOCP* 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);

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


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

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


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

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


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

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


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

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


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

        std::vector< double > ret = obj->start(x0_);
        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: "start" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::start"
// cWrapperName: "casadi__SymbolicOCP__start__1"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* casadi__SymbolicOCP__start__1(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1)"
// call: "obj->start(x0_, x1_)"
// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX"))),CBool]
extern "C"
    std::vector< double >* casadi__SymbolicOCP__start__1(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1);
std::vector< double >* casadi__SymbolicOCP__start__1(std::string ** err_msg, casadi::SymbolicOCP* obj, casadi::SX* x0, int x1){
    try {
        casadi::SX x0_ = Marshaling<casadi::SX,casadi::SX*>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        std::vector< double > ret = obj->start(x0_, x1_);
        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: "start" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::start"
// cWrapperName: "casadi__SymbolicOCP__start__2"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double casadi__SymbolicOCP__start__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->start(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    double casadi__SymbolicOCP__start__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0);
double casadi__SymbolicOCP__start__2(std::string ** err_msg, casadi::SymbolicOCP* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


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

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


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

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


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

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


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

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


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

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


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::getRepresentation"
// cWrapperName: "casadi__SymbolicOCP__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SymbolicOCP__getRepresentation(std::string ** err_msg, casadi::SymbolicOCP* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__SymbolicOCP__getRepresentation(std::string ** err_msg, casadi::SymbolicOCP* obj);
std::string* casadi__SymbolicOCP__getRepresentation(std::string ** err_msg, casadi::SymbolicOCP* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::SymbolicOCP"
// cppName: "casadi::SymbolicOCP::getDescription"
// cWrapperName: "casadi__SymbolicOCP__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::SymbolicOCP* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__SymbolicOCP__getDescription(std::string ** err_msg, casadi::SymbolicOCP* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__SymbolicOCP__getDescription(std::string ** err_msg, casadi::SymbolicOCP* obj);
std::string* casadi__SymbolicOCP__getDescription(std::string ** err_msg, casadi::SymbolicOCP* 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;
    }
}



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

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

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


// ================== Normal method: "atTime" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::atTime"
// cWrapperName: "casadi__Variable__atTime__0"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__Variable__atTime__0(std::string ** err_msg, casadi::Variable* obj, double x0)"
// call: "obj->atTime(x0_)"
// params: [CDouble]
extern "C"
    casadi::SXElement* casadi__Variable__atTime__0(std::string ** err_msg, casadi::Variable* obj, double x0);
casadi::SXElement* casadi__Variable__atTime__0(std::string ** err_msg, casadi::Variable* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

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


// ================== Normal method: "atTime" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::atTime"
// cWrapperName: "casadi__Variable__atTime__1"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__Variable__atTime__1(std::string ** err_msg, casadi::Variable* obj, double x0, int x1)"
// call: "obj->atTime(x0_, x1_)"
// params: [CDouble,CBool]
extern "C"
    casadi::SXElement* casadi__Variable__atTime__1(std::string ** err_msg, casadi::Variable* obj, double x0, int x1);
casadi::SXElement* casadi__Variable__atTime__1(std::string ** err_msg, casadi::Variable* obj, double x0, int x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::SXElement ret = obj->atTime(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: "atTime" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::atTime"
// cWrapperName: "casadi__Variable__atTime__2"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj, double x0)"
// args: "(x0_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__Variable__atTime__2(std::string ** err_msg, casadi::Variable* obj, double x0)"
// call: "obj->atTime(x0_)"
// params: [CDouble]
extern "C"
    casadi::SXElement* casadi__Variable__atTime__2(std::string ** err_msg, casadi::Variable* obj, double x0);
casadi::SXElement* casadi__Variable__atTime__2(std::string ** err_msg, casadi::Variable* obj, double x0){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);

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


// ================== Normal method: "atTime" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::atTime"
// cWrapperName: "casadi__Variable__atTime__3"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: UserType (Namespace ["casadi"]) (Name "SXElement")
// cWrapperRetType: "casadi::SXElement*"
// proto: "casadi::SXElement* casadi__Variable__atTime__3(std::string ** err_msg, casadi::Variable* obj, double x0, int x1)"
// call: "obj->atTime(x0_, x1_)"
// params: [CDouble,CBool]
extern "C"
    casadi::SXElement* casadi__Variable__atTime__3(std::string ** err_msg, casadi::Variable* obj, double x0, int x1);
casadi::SXElement* casadi__Variable__atTime__3(std::string ** err_msg, casadi::Variable* obj, double x0, int x1){
    try {
        double x0_ = Marshaling<double,double>::marshal(x0);
        bool x1_ = Marshaling<bool,int>::marshal(x1);

        casadi::SXElement ret = obj->atTime(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: "name" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::name"
// cWrapperName: "casadi__Variable__name"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj)"
// call: "obj->name()"
// params: []
extern "C"
    std::string* casadi__Variable__name(std::string ** err_msg, casadi::Variable* obj);
std::string* casadi__Variable__name(std::string ** err_msg, casadi::Variable* 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: "setName" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::setName"
// cWrapperName: "casadi__Variable__setName"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__Variable__setName(std::string ** err_msg, casadi::Variable* obj, std::string* x0)"
// call: "obj->setName(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__Variable__setName(std::string ** err_msg, casadi::Variable* obj, std::string* x0);
void casadi__Variable__setName(std::string ** err_msg, casadi::Variable* obj, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

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


// ================== Normal method: "getRepresentation" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::getRepresentation"
// cWrapperName: "casadi__Variable__getRepresentation"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj)"
// call: "obj->getRepresentation()"
// params: []
extern "C"
    std::string* casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* obj);
std::string* casadi__Variable__getRepresentation(std::string ** err_msg, casadi::Variable* 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;
    }
}


// ================== Normal method: "getDescription" ===============
// class: "casadi::Variable"
// cppName: "casadi::Variable::getDescription"
// cWrapperName: "casadi__Variable__getDescription"
// protoArgs: "(std::string ** err_msg, casadi::Variable* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj)"
// call: "obj->getDescription()"
// params: []
extern "C"
    std::string* casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* obj);
std::string* casadi__Variable__getDescription(std::string ** err_msg, casadi::Variable* 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;
    }
}



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

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

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


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

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


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

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


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

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



// ================== 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;
    }
}