casadi-bindings-1.9.0.0: cbits/autogen/all.cpp

#include <swiginclude.hpp>
#include "../marshal.hpp"
#include <symbolic/functor_internal.hpp>
#include <symbolic/function/custom_function.hpp>
// ================== delete CasadiClass SXFunction===============
// classType: CasadiClass SXFunction
extern "C"
    void delete_CasADi__SXFunction(CasADi::SXFunction* obj);
void delete_CasADi__SXFunction(CasADi::SXFunction* obj){
    delete obj;
}

// ================== Normal method: "jac" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac"
// cWrapperName: "CasADi__SXFunction__jac"
// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, int x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, int x2, int x3){
    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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac'" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'"
// cWrapperName: "CasADi__SXFunction__jac_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC(CasADi::SXFunction* obj, int x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC(CasADi::SXFunction* obj, int x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC(CasADi::SXFunction* obj, int x0, int x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC(CasADi::SXFunction* obj, int x0, int x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC(CasADi::SXFunction* obj, int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC(CasADi::SXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "jac'''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0)"
// call: "obj->jac(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_) );
}


// ================== Normal method: "jac''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj)"
// call: "obj->jac()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac() );
}


// ================== Normal method: "jac'''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1, int x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac'''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "jac''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0)"
// call: "obj->jac(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_) );
}


// ================== Normal method: "jac'''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1, int x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1, int x2, int x3){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac''''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac'''''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'''''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "jac''''''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''''''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac'''''''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac'''''''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac''''''''''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::jac''''''''''''''"
// cWrapperName: "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "grad" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad"
// cWrapperName: "CasADi__SXFunction__grad"
// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "grad'" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad'"
// cWrapperName: "CasADi__SXFunction__grad_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC(CasADi::SXFunction* obj, int x0)"
// call: "obj->grad(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC(CasADi::SXFunction* obj, int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad(x0_) );
}


// ================== Normal method: "grad''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad''"
// cWrapperName: "CasADi__SXFunction__grad_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC(CasADi::SXFunction* obj)"
// call: "obj->grad()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC(CasADi::SXFunction* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC(CasADi::SXFunction* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad() );
}


// ================== Normal method: "grad'''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad'''"
// cWrapperName: "CasADi__SXFunction__grad_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "grad''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad''''"
// cWrapperName: "CasADi__SXFunction__grad_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0)"
// call: "obj->grad(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad(x0_) );
}


// ================== Normal method: "grad'''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad'''''"
// cWrapperName: "CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "grad''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::grad''''''"
// cWrapperName: "CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "tang" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang"
// cWrapperName: "CasADi__SXFunction__tang"
// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang(CasADi::SXFunction* obj, int x0, int x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang(CasADi::SXFunction* obj, int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang(CasADi::SXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "tang'" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang'"
// cWrapperName: "CasADi__SXFunction__tang_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC(CasADi::SXFunction* obj, int x0)"
// call: "obj->tang(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC(CasADi::SXFunction* obj, int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang(x0_) );
}


// ================== Normal method: "tang''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang''"
// cWrapperName: "CasADi__SXFunction__tang_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC(CasADi::SXFunction* obj)"
// call: "obj->tang()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC(CasADi::SXFunction* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC(CasADi::SXFunction* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang() );
}


// ================== Normal method: "tang'''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang'''"
// cWrapperName: "CasADi__SXFunction__tang_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "tang''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang''''"
// cWrapperName: "CasADi__SXFunction__tang_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0)"
// call: "obj->tang(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang(x0_) );
}


// ================== Normal method: "tang'''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang'''''"
// cWrapperName: "CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "tang''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::tang''''''"
// cWrapperName: "CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "hess" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess"
// cWrapperName: "CasADi__SXFunction__hess"
// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1)"
// call: "obj->hess(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess(x0_, x1_) );
}


// ================== Normal method: "hess'" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess'"
// cWrapperName: "CasADi__SXFunction__hess_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC(CasADi::SXFunction* obj, int x0)"
// call: "obj->hess(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC(CasADi::SXFunction* obj, int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess(x0_) );
}


// ================== Normal method: "hess''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess''"
// cWrapperName: "CasADi__SXFunction__hess_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC(CasADi::SXFunction* obj)"
// call: "obj->hess()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC(CasADi::SXFunction* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC(CasADi::SXFunction* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess() );
}


// ================== Normal method: "hess'''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess'''"
// cWrapperName: "CasADi__SXFunction__hess_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1)"
// call: "obj->hess(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess(x0_, x1_) );
}


// ================== Normal method: "hess''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess''''"
// cWrapperName: "CasADi__SXFunction__hess_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0)"
// call: "obj->hess(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess(x0_) );
}


// ================== Normal method: "hess'''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess'''''"
// cWrapperName: "CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1)"
// call: "obj->hess(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess(x0_, x1_) );
}


// ================== Normal method: "hess''''''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::hess''''''"
// cWrapperName: "CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->hess(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->hess(x0_, x1_) );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::checkNode"
// cWrapperName: "CasADi__SXFunction__checkNode"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXFunction__checkNode(CasADi::SXFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SXFunction__checkNode(CasADi::SXFunction* obj);
int CasADi__SXFunction__checkNode(CasADi::SXFunction* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getAlgorithmSize" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getAlgorithmSize"
// cWrapperName: "CasADi__SXFunction__getAlgorithmSize"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXFunction__getAlgorithmSize(CasADi::SXFunction* obj)"
// call: "obj->getAlgorithmSize()"
extern "C"
    int CasADi__SXFunction__getAlgorithmSize(CasADi::SXFunction* obj);
int CasADi__SXFunction__getAlgorithmSize(CasADi::SXFunction* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getAlgorithmSize() );
}


// ================== Normal method: "getWorkSize" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getWorkSize"
// cWrapperName: "CasADi__SXFunction__getWorkSize"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXFunction__getWorkSize(CasADi::SXFunction* obj)"
// call: "obj->getWorkSize()"
extern "C"
    int CasADi__SXFunction__getWorkSize(CasADi::SXFunction* obj);
int CasADi__SXFunction__getWorkSize(CasADi::SXFunction* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getWorkSize() );
}


// ================== Normal method: "getAtomicOperation" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getAtomicOperation"
// cWrapperName: "CasADi__SXFunction__getAtomicOperation"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXFunction__getAtomicOperation(CasADi::SXFunction* obj, int x0)"
// call: "obj->getAtomicOperation(x0_)"
extern "C"
    int CasADi__SXFunction__getAtomicOperation(CasADi::SXFunction* obj, int x0);
int CasADi__SXFunction__getAtomicOperation(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->getAtomicOperation(x0_) );
}


// ================== Normal method: "getAtomicInputReal" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getAtomicInputReal"
// cWrapperName: "CasADi__SXFunction__getAtomicInputReal"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SXFunction__getAtomicInputReal(CasADi::SXFunction* obj, int x0)"
// call: "obj->getAtomicInputReal(x0_)"
extern "C"
    double CasADi__SXFunction__getAtomicInputReal(CasADi::SXFunction* obj, int x0);
double CasADi__SXFunction__getAtomicInputReal(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( obj->getAtomicInputReal(x0_) );
}


// ================== Normal method: "getAtomicOutput" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getAtomicOutput"
// cWrapperName: "CasADi__SXFunction__getAtomicOutput"
// protoArgs: "(CasADi::SXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXFunction__getAtomicOutput(CasADi::SXFunction* obj, int x0)"
// call: "obj->getAtomicOutput(x0_)"
extern "C"
    int CasADi__SXFunction__getAtomicOutput(CasADi::SXFunction* obj, int x0);
int CasADi__SXFunction__getAtomicOutput(CasADi::SXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->getAtomicOutput(x0_) );
}


// ================== Normal method: "countNodes" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::countNodes"
// cWrapperName: "CasADi__SXFunction__countNodes"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXFunction__countNodes(CasADi::SXFunction* obj)"
// call: "obj->countNodes()"
extern "C"
    int CasADi__SXFunction__countNodes(CasADi::SXFunction* obj);
int CasADi__SXFunction__countNodes(CasADi::SXFunction* obj){

    return WrapReturn< int, int >::wrapReturn( obj->countNodes() );
}


// ================== Normal method: "clearSymbolic" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::clearSymbolic"
// cWrapperName: "CasADi__SXFunction__clearSymbolic"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SXFunction__clearSymbolic(CasADi::SXFunction* obj)"
// call: "obj->clearSymbolic()"
extern "C"
    void CasADi__SXFunction__clearSymbolic(CasADi::SXFunction* obj);
void CasADi__SXFunction__clearSymbolic(CasADi::SXFunction* obj){

    obj->clearSymbolic();
}


// ================== Normal method: "getFree" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getFree"
// cWrapperName: "CasADi__SXFunction__getFree"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: StdVec (CasadiClass SXElement)
// cWrapperRetType: "std::vector< CasADi::SXElement* >*"
// proto: "std::vector< CasADi::SXElement* >* CasADi__SXFunction__getFree(CasADi::SXFunction* obj)"
// call: "obj->getFree()"
extern "C"
    std::vector< CasADi::SXElement* >* CasADi__SXFunction__getFree(CasADi::SXFunction* obj);
std::vector< CasADi::SXElement* >* CasADi__SXFunction__getFree(CasADi::SXFunction* obj){

    return WrapReturn< std::vector< CasADi::SXElement* >*, std::vector< CasADi::SXElement > >::wrapReturn( obj->getFree() );
}


// ================== Constructor method: "SXFunction" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction"
// cWrapperName: "CasADi__SXFunction__SXFunction"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SXFunction
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction()"
// call: "CasADi::SXFunction()"
extern "C"
    CasADi::SXFunction* CasADi__SXFunction__SXFunction();
CasADi::SXFunction* CasADi__SXFunction__SXFunction(){

    return WrapReturn< CasADi::SXFunction*, CasADi::SXFunction >::wrapReturn( CasADi::SXFunction() );
}


// ================== Constructor method: "SXFunction'" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction"
// cWrapperName: "CasADi__SXFunction__SXFunction_TIC"
// protoArgs: "(CasADi::MXFunction* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXFunction
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC(CasADi::MXFunction* x0)"
// call: "CasADi::SXFunction(x0_)"
extern "C"
    CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC(CasADi::MXFunction* x0);
CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC(CasADi::MXFunction* x0){
    CasADi::MXFunction const & x0_ = Marshaling<CasADi::MXFunction const &,CasADi::MXFunction*>::marshal(x0);

    return WrapReturn< CasADi::SXFunction*, CasADi::SXFunction >::wrapReturn( CasADi::SXFunction(x0_) );
}


// ================== Constructor method: "SXFunction''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction"
// cWrapperName: "CasADi__SXFunction__SXFunction_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXFunction
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::SXFunction(x0_)"
extern "C"
    CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC(CasADi::Function* x0);
CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::SXFunction*, CasADi::SXFunction >::wrapReturn( CasADi::SXFunction(x0_) );
}


// ================== Constructor method: "SXFunction'''" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction"
// cWrapperName: "CasADi__SXFunction__SXFunction_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SXFunction
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1)"
// call: "CasADi::SXFunction(x0_, x1_)"
extern "C"
    CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1);
CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);

    return WrapReturn< CasADi::SXFunction*, CasADi::SXFunction >::wrapReturn( CasADi::SXFunction(x0_, x1_) );
}


// ================== delete CasadiClass RKIntegrator===============
// classType: CasadiClass RKIntegrator
extern "C"
    void delete_CasADi__RKIntegrator(CasADi::RKIntegrator* obj);
void delete_CasADi__RKIntegrator(CasADi::RKIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::RKIntegrator"
// cppName: "CasADi::RKIntegrator::checkNode"
// cWrapperName: "CasADi__RKIntegrator__checkNode"
// protoArgs: "(CasADi::RKIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__RKIntegrator__checkNode(CasADi::RKIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__RKIntegrator__checkNode(CasADi::RKIntegrator* obj);
int CasADi__RKIntegrator__checkNode(CasADi::RKIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::RKIntegrator"
// cppName: "CasADi::RKIntegrator::creator"
// cWrapperName: "CasADi__RKIntegrator__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__RKIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::RKIntegrator::creator(x0_, x1_)"
extern "C"
    CasADi::Integrator* CasADi__RKIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1);
CasADi::Integrator* CasADi__RKIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( CasADi::RKIntegrator::creator(x0_, x1_) );
}


// ================== Constructor method: "RKIntegrator" ===============
// class: "CasADi::RKIntegrator"
// cppName: "CasADi::RKIntegrator"
// cWrapperName: "CasADi__RKIntegrator__RKIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass RKIntegrator
// cWrapperRetType: "CasADi::RKIntegrator*"
// proto: "CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator()"
// call: "CasADi::RKIntegrator()"
extern "C"
    CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator();
CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator(){

    return WrapReturn< CasADi::RKIntegrator*, CasADi::RKIntegrator >::wrapReturn( CasADi::RKIntegrator() );
}


// ================== Constructor method: "RKIntegrator'" ===============
// class: "CasADi::RKIntegrator"
// cppName: "CasADi::RKIntegrator"
// cWrapperName: "CasADi__RKIntegrator__RKIntegrator_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass RKIntegrator
// cWrapperRetType: "CasADi::RKIntegrator*"
// proto: "CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::RKIntegrator(x0_, x1_)"
extern "C"
    CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::RKIntegrator*, CasADi::RKIntegrator >::wrapReturn( CasADi::RKIntegrator(x0_, x1_) );
}


// ================== Constructor method: "RKIntegrator''" ===============
// class: "CasADi::RKIntegrator"
// cppName: "CasADi::RKIntegrator"
// cWrapperName: "CasADi__RKIntegrator__RKIntegrator_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass RKIntegrator
// cWrapperRetType: "CasADi::RKIntegrator*"
// proto: "CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::RKIntegrator(x0_)"
extern "C"
    CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator_TIC_TIC(CasADi::Function* x0);
CasADi::RKIntegrator* CasADi__RKIntegrator__RKIntegrator_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::RKIntegrator*, CasADi::RKIntegrator >::wrapReturn( CasADi::RKIntegrator(x0_) );
}


// ================== delete CasadiClass SQPMethod===============
// classType: CasadiClass SQPMethod
extern "C"
    void delete_CasADi__SQPMethod(CasADi::SQPMethod* obj);
void delete_CasADi__SQPMethod(CasADi::SQPMethod* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SQPMethod"
// cppName: "CasADi::SQPMethod::checkNode"
// cWrapperName: "CasADi__SQPMethod__checkNode"
// protoArgs: "(CasADi::SQPMethod* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SQPMethod__checkNode(CasADi::SQPMethod* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SQPMethod__checkNode(CasADi::SQPMethod* obj);
int CasADi__SQPMethod__checkNode(CasADi::SQPMethod* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SQPMethod"
// cppName: "CasADi::SQPMethod::creator"
// cWrapperName: "CasADi__SQPMethod__creator"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__SQPMethod__creator(CasADi::Function* x0)"
// call: "CasADi::SQPMethod::creator(x0_)"
extern "C"
    CasADi::NLPSolver* CasADi__SQPMethod__creator(CasADi::Function* x0);
CasADi::NLPSolver* CasADi__SQPMethod__creator(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( CasADi::SQPMethod::creator(x0_) );
}


// ================== Constructor method: "SQPMethod" ===============
// class: "CasADi::SQPMethod"
// cppName: "CasADi::SQPMethod"
// cWrapperName: "CasADi__SQPMethod__SQPMethod"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SQPMethod
// cWrapperRetType: "CasADi::SQPMethod*"
// proto: "CasADi::SQPMethod* CasADi__SQPMethod__SQPMethod()"
// call: "CasADi::SQPMethod()"
extern "C"
    CasADi::SQPMethod* CasADi__SQPMethod__SQPMethod();
CasADi::SQPMethod* CasADi__SQPMethod__SQPMethod(){

    return WrapReturn< CasADi::SQPMethod*, CasADi::SQPMethod >::wrapReturn( CasADi::SQPMethod() );
}


// ================== Constructor method: "SQPMethod'" ===============
// class: "CasADi::SQPMethod"
// cppName: "CasADi::SQPMethod"
// cWrapperName: "CasADi__SQPMethod__SQPMethod_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass SQPMethod
// cWrapperRetType: "CasADi::SQPMethod*"
// proto: "CasADi::SQPMethod* CasADi__SQPMethod__SQPMethod_TIC(CasADi::Function* x0)"
// call: "CasADi::SQPMethod(x0_)"
extern "C"
    CasADi::SQPMethod* CasADi__SQPMethod__SQPMethod_TIC(CasADi::Function* x0);
CasADi::SQPMethod* CasADi__SQPMethod__SQPMethod_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::SQPMethod*, CasADi::SQPMethod >::wrapReturn( CasADi::SQPMethod(x0_) );
}


// ================== delete CasadiClass SharedObject===============
// classType: CasadiClass SharedObject
extern "C"
    void delete_CasADi__SharedObject(CasADi::SharedObject* obj);
void delete_CasADi__SharedObject(CasADi::SharedObject* obj){
    delete obj;
}

// ================== Normal method: "printPtr'" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::printPtr'"
// cWrapperName: "CasADi__SharedObject__printPtr_TIC"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SharedObject__printPtr_TIC(CasADi::SharedObject* obj)"
// call: "obj->printPtr()"
extern "C"
    void CasADi__SharedObject__printPtr_TIC(CasADi::SharedObject* obj);
void CasADi__SharedObject__printPtr_TIC(CasADi::SharedObject* obj){

    obj->printPtr();
}


// ================== Normal method: "init" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::init"
// cWrapperName: "CasADi__SharedObject__init"
// protoArgs: "(CasADi::SharedObject* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SharedObject__init(CasADi::SharedObject* obj, int x0)"
// call: "obj->init(x0_)"
extern "C"
    void CasADi__SharedObject__init(CasADi::SharedObject* obj, int x0);
void CasADi__SharedObject__init(CasADi::SharedObject* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->init(x0_);
}


// ================== Normal method: "init'" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::init'"
// cWrapperName: "CasADi__SharedObject__init_TIC"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SharedObject__init_TIC(CasADi::SharedObject* obj)"
// call: "obj->init()"
extern "C"
    void CasADi__SharedObject__init_TIC(CasADi::SharedObject* obj);
void CasADi__SharedObject__init_TIC(CasADi::SharedObject* obj){

    obj->init();
}


// ================== Normal method: "isInit" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::isInit"
// cWrapperName: "CasADi__SharedObject__isInit"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SharedObject__isInit(CasADi::SharedObject* obj)"
// call: "obj->isInit()"
extern "C"
    int CasADi__SharedObject__isInit(CasADi::SharedObject* obj);
int CasADi__SharedObject__isInit(CasADi::SharedObject* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInit() );
}


// ================== Normal method: "assertInit" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::assertInit"
// cWrapperName: "CasADi__SharedObject__assertInit"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SharedObject__assertInit(CasADi::SharedObject* obj)"
// call: "obj->assertInit()"
extern "C"
    void CasADi__SharedObject__assertInit(CasADi::SharedObject* obj);
void CasADi__SharedObject__assertInit(CasADi::SharedObject* obj){

    obj->assertInit();
}


// ================== Normal method: "isNull" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::isNull"
// cWrapperName: "CasADi__SharedObject__isNull"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SharedObject__isNull(CasADi::SharedObject* obj)"
// call: "obj->isNull()"
extern "C"
    int CasADi__SharedObject__isNull(CasADi::SharedObject* obj);
int CasADi__SharedObject__isNull(CasADi::SharedObject* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isNull() );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::checkNode"
// cWrapperName: "CasADi__SharedObject__checkNode"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SharedObject__checkNode(CasADi::SharedObject* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SharedObject__checkNode(CasADi::SharedObject* obj);
int CasADi__SharedObject__checkNode(CasADi::SharedObject* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "makeUnique" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::makeUnique"
// cWrapperName: "CasADi__SharedObject__makeUnique"
// protoArgs: "(CasADi::SharedObject* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SharedObject__makeUnique(CasADi::SharedObject* obj, int x0)"
// call: "obj->makeUnique(x0_)"
extern "C"
    void CasADi__SharedObject__makeUnique(CasADi::SharedObject* obj, int x0);
void CasADi__SharedObject__makeUnique(CasADi::SharedObject* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->makeUnique(x0_);
}


// ================== Normal method: "makeUnique'" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::makeUnique'"
// cWrapperName: "CasADi__SharedObject__makeUnique_TIC"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SharedObject__makeUnique_TIC(CasADi::SharedObject* obj)"
// call: "obj->makeUnique()"
extern "C"
    void CasADi__SharedObject__makeUnique_TIC(CasADi::SharedObject* obj);
void CasADi__SharedObject__makeUnique_TIC(CasADi::SharedObject* obj){

    obj->makeUnique();
}


// ================== delete CasadiClass MXFunction===============
// classType: CasadiClass MXFunction
extern "C"
    void delete_CasADi__MXFunction(CasADi::MXFunction* obj);
void delete_CasADi__MXFunction(CasADi::MXFunction* obj){
    delete obj;
}

// ================== Normal method: "getAlgorithmSize" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::getAlgorithmSize"
// cWrapperName: "CasADi__MXFunction__getAlgorithmSize"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MXFunction__getAlgorithmSize(CasADi::MXFunction* obj)"
// call: "obj->getAlgorithmSize()"
extern "C"
    int CasADi__MXFunction__getAlgorithmSize(CasADi::MXFunction* obj);
int CasADi__MXFunction__getAlgorithmSize(CasADi::MXFunction* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getAlgorithmSize() );
}


// ================== Normal method: "getWorkSize" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::getWorkSize"
// cWrapperName: "CasADi__MXFunction__getWorkSize"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MXFunction__getWorkSize(CasADi::MXFunction* obj)"
// call: "obj->getWorkSize()"
extern "C"
    int CasADi__MXFunction__getWorkSize(CasADi::MXFunction* obj);
int CasADi__MXFunction__getWorkSize(CasADi::MXFunction* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getWorkSize() );
}


// ================== Normal method: "countNodes" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::countNodes"
// cWrapperName: "CasADi__MXFunction__countNodes"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MXFunction__countNodes(CasADi::MXFunction* obj)"
// call: "obj->countNodes()"
extern "C"
    int CasADi__MXFunction__countNodes(CasADi::MXFunction* obj);
int CasADi__MXFunction__countNodes(CasADi::MXFunction* obj){

    return WrapReturn< int, int >::wrapReturn( obj->countNodes() );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::checkNode"
// cWrapperName: "CasADi__MXFunction__checkNode"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MXFunction__checkNode(CasADi::MXFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__MXFunction__checkNode(CasADi::MXFunction* obj);
int CasADi__MXFunction__checkNode(CasADi::MXFunction* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "jac" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac"
// cWrapperName: "CasADi__MXFunction__jac"
// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac(CasADi::MXFunction* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac(CasADi::MXFunction* obj, int x0, int x1, int x2, int x3);
CasADi::MX* CasADi__MXFunction__jac(CasADi::MXFunction* obj, int x0, int x1, int x2, int x3){
    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);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac'" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'"
// cWrapperName: "CasADi__MXFunction__jac_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC(CasADi::MXFunction* obj, int x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC(CasADi::MXFunction* obj, int x0, int x1, int x2);
CasADi::MX* CasADi__MXFunction__jac_TIC(CasADi::MXFunction* obj, int x0, int x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC(CasADi::MXFunction* obj, int x0, int x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC(CasADi::MXFunction* obj, int x0, int x1);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC(CasADi::MXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "jac'''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0)"
// call: "obj->jac(x0_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_) );
}


// ================== Normal method: "jac''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj)"
// call: "obj->jac()"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac() );
}


// ================== Normal method: "jac'''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1, int x2, int x3);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1, int x2);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac'''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "jac''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0)"
// call: "obj->jac(x0_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_) );
}


// ================== Normal method: "jac'''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1, int x2, int x3);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1, int x2, int x3){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac''''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1, int x2);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac'''''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'''''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "jac''''''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''''''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jac'''''''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac'''''''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jac(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_, x2_) );
}


// ================== Normal method: "jac''''''''''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::jac''''''''''''''"
// cWrapperName: "CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->jac(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1);
CasADi::MX* CasADi__MXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->jac(x0_, x1_) );
}


// ================== Normal method: "grad" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad"
// cWrapperName: "CasADi__MXFunction__grad"
// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad(CasADi::MXFunction* obj, int x0, int x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad(CasADi::MXFunction* obj, int x0, int x1);
CasADi::MX* CasADi__MXFunction__grad(CasADi::MXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "grad'" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad'"
// cWrapperName: "CasADi__MXFunction__grad_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad_TIC(CasADi::MXFunction* obj, int x0)"
// call: "obj->grad(x0_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad_TIC(CasADi::MXFunction* obj, int x0);
CasADi::MX* CasADi__MXFunction__grad_TIC(CasADi::MXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad(x0_) );
}


// ================== Normal method: "grad''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad''"
// cWrapperName: "CasADi__MXFunction__grad_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad_TIC_TIC(CasADi::MXFunction* obj)"
// call: "obj->grad()"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad_TIC_TIC(CasADi::MXFunction* obj);
CasADi::MX* CasADi__MXFunction__grad_TIC_TIC(CasADi::MXFunction* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad() );
}


// ================== Normal method: "grad'''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad'''"
// cWrapperName: "CasADi__MXFunction__grad_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1);
CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "grad''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad''''"
// cWrapperName: "CasADi__MXFunction__grad_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0)"
// call: "obj->grad(x0_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0);
CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad(x0_) );
}


// ================== Normal method: "grad'''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad'''''"
// cWrapperName: "CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1);
CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "grad''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::grad''''''"
// cWrapperName: "CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1);
CasADi::MX* CasADi__MXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->grad(x0_, x1_) );
}


// ================== Normal method: "tang" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang"
// cWrapperName: "CasADi__MXFunction__tang"
// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang(CasADi::MXFunction* obj, int x0, int x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang(CasADi::MXFunction* obj, int x0, int x1);
CasADi::MX* CasADi__MXFunction__tang(CasADi::MXFunction* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "tang'" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang'"
// cWrapperName: "CasADi__MXFunction__tang_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang_TIC(CasADi::MXFunction* obj, int x0)"
// call: "obj->tang(x0_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang_TIC(CasADi::MXFunction* obj, int x0);
CasADi::MX* CasADi__MXFunction__tang_TIC(CasADi::MXFunction* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang(x0_) );
}


// ================== Normal method: "tang''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang''"
// cWrapperName: "CasADi__MXFunction__tang_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang_TIC_TIC(CasADi::MXFunction* obj)"
// call: "obj->tang()"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang_TIC_TIC(CasADi::MXFunction* obj);
CasADi::MX* CasADi__MXFunction__tang_TIC_TIC(CasADi::MXFunction* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang() );
}


// ================== Normal method: "tang'''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang'''"
// cWrapperName: "CasADi__MXFunction__tang_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1);
CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "tang''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang''''"
// cWrapperName: "CasADi__MXFunction__tang_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0)"
// call: "obj->tang(x0_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0);
CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang(x0_) );
}


// ================== Normal method: "tang'''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang'''''"
// cWrapperName: "CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1);
CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "tang''''''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::tang''''''"
// cWrapperName: "CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MXFunction* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1)"
// call: "obj->tang(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1);
CasADi::MX* CasADi__MXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MXFunction* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tang(x0_, x1_) );
}


// ================== Normal method: "expand" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::expand"
// cWrapperName: "CasADi__MXFunction__expand"
// protoArgs: "(CasADi::MXFunction* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXFunction
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__MXFunction__expand(CasADi::MXFunction* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "obj->expand(x0_)"
extern "C"
    CasADi::SXFunction* CasADi__MXFunction__expand(CasADi::MXFunction* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::SXFunction* CasADi__MXFunction__expand(CasADi::MXFunction* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::SXFunction*, CasADi::SXFunction >::wrapReturn( obj->expand(x0_) );
}


// ================== Normal method: "expand'" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::expand'"
// cWrapperName: "CasADi__MXFunction__expand_TIC"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: CasadiClass SXFunction
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__MXFunction__expand_TIC(CasADi::MXFunction* obj)"
// call: "obj->expand()"
extern "C"
    CasADi::SXFunction* CasADi__MXFunction__expand_TIC(CasADi::MXFunction* obj);
CasADi::SXFunction* CasADi__MXFunction__expand_TIC(CasADi::MXFunction* obj){

    return WrapReturn< CasADi::SXFunction*, CasADi::SXFunction >::wrapReturn( obj->expand() );
}


// ================== Normal method: "getFree" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::getFree"
// cWrapperName: "CasADi__MXFunction__getFree"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__MXFunction__getFree(CasADi::MXFunction* obj)"
// call: "obj->getFree()"
extern "C"
    std::vector< CasADi::MX* >* CasADi__MXFunction__getFree(CasADi::MXFunction* obj);
std::vector< CasADi::MX* >* CasADi__MXFunction__getFree(CasADi::MXFunction* obj){

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( obj->getFree() );
}


// ================== Normal method: "generateLiftingFunctions" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::generateLiftingFunctions"
// cWrapperName: "CasADi__MXFunction__generateLiftingFunctions"
// protoArgs: "(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MXFunction__generateLiftingFunctions(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1)"
// call: "obj->generateLiftingFunctions(x0_, x1_)"
extern "C"
    void CasADi__MXFunction__generateLiftingFunctions(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1);
void CasADi__MXFunction__generateLiftingFunctions(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1){
    CasADi::MXFunction& x0_ = Marshaling<CasADi::MXFunction&,CasADi::MXFunction*>::marshal(x0);
    CasADi::MXFunction& x1_ = Marshaling<CasADi::MXFunction&,CasADi::MXFunction*>::marshal(x1);

    obj->generateLiftingFunctions(x0_, x1_);
}


// ================== Constructor method: "MXFunction" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction"
// cWrapperName: "CasADi__MXFunction__MXFunction"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MXFunction
// cWrapperRetType: "CasADi::MXFunction*"
// proto: "CasADi::MXFunction* CasADi__MXFunction__MXFunction()"
// call: "CasADi::MXFunction()"
extern "C"
    CasADi::MXFunction* CasADi__MXFunction__MXFunction();
CasADi::MXFunction* CasADi__MXFunction__MXFunction(){

    return WrapReturn< CasADi::MXFunction*, CasADi::MXFunction >::wrapReturn( CasADi::MXFunction() );
}


// ================== Constructor method: "MXFunction'" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction"
// cWrapperName: "CasADi__MXFunction__MXFunction_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass MXFunction
// cWrapperRetType: "CasADi::MXFunction*"
// proto: "CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC(CasADi::Function* x0)"
// call: "CasADi::MXFunction(x0_)"
extern "C"
    CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC(CasADi::Function* x0);
CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::MXFunction*, CasADi::MXFunction >::wrapReturn( CasADi::MXFunction(x0_) );
}


// ================== Constructor method: "MXFunction''" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction"
// cWrapperName: "CasADi__MXFunction__MXFunction_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MXFunction
// cWrapperRetType: "CasADi::MXFunction*"
// proto: "CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::MXFunction(x0_, x1_)"
extern "C"
    CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1);
CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1){
    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);

    return WrapReturn< CasADi::MXFunction*, CasADi::MXFunction >::wrapReturn( CasADi::MXFunction(x0_, x1_) );
}


// ================== delete CasadiClass HomotopyNLPSolver===============
// classType: CasadiClass HomotopyNLPSolver
extern "C"
    void delete_CasADi__HomotopyNLPSolver(CasADi::HomotopyNLPSolver* obj);
void delete_CasADi__HomotopyNLPSolver(CasADi::HomotopyNLPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::HomotopyNLPSolver"
// cppName: "CasADi::HomotopyNLPSolver::checkNode"
// cWrapperName: "CasADi__HomotopyNLPSolver__checkNode"
// protoArgs: "(CasADi::HomotopyNLPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__HomotopyNLPSolver__checkNode(CasADi::HomotopyNLPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__HomotopyNLPSolver__checkNode(CasADi::HomotopyNLPSolver* obj);
int CasADi__HomotopyNLPSolver__checkNode(CasADi::HomotopyNLPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "HomotopyNLPSolver" ===============
// class: "CasADi::HomotopyNLPSolver"
// cppName: "CasADi::HomotopyNLPSolver"
// cWrapperName: "CasADi__HomotopyNLPSolver__HomotopyNLPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass HomotopyNLPSolver
// cWrapperRetType: "CasADi::HomotopyNLPSolver*"
// proto: "CasADi::HomotopyNLPSolver* CasADi__HomotopyNLPSolver__HomotopyNLPSolver()"
// call: "CasADi::HomotopyNLPSolver()"
extern "C"
    CasADi::HomotopyNLPSolver* CasADi__HomotopyNLPSolver__HomotopyNLPSolver();
CasADi::HomotopyNLPSolver* CasADi__HomotopyNLPSolver__HomotopyNLPSolver(){

    return WrapReturn< CasADi::HomotopyNLPSolver*, CasADi::HomotopyNLPSolver >::wrapReturn( CasADi::HomotopyNLPSolver() );
}


// ================== delete CasadiClass StabilizedQPSolver===============
// classType: CasadiClass StabilizedQPSolver
extern "C"
    void delete_CasADi__StabilizedQPSolver(CasADi::StabilizedQPSolver* obj);
void delete_CasADi__StabilizedQPSolver(CasADi::StabilizedQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::StabilizedQPSolver"
// cppName: "CasADi::StabilizedQPSolver::checkNode"
// cWrapperName: "CasADi__StabilizedQPSolver__checkNode"
// protoArgs: "(CasADi::StabilizedQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__StabilizedQPSolver__checkNode(CasADi::StabilizedQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__StabilizedQPSolver__checkNode(CasADi::StabilizedQPSolver* obj);
int CasADi__StabilizedQPSolver__checkNode(CasADi::StabilizedQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "setLPOptions" ===============
// class: "CasADi::StabilizedQPSolver"
// cppName: "CasADi::StabilizedQPSolver::setLPOptions"
// cWrapperName: "CasADi__StabilizedQPSolver__setLPOptions"
// protoArgs: "(CasADi::StabilizedQPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__StabilizedQPSolver__setLPOptions(CasADi::StabilizedQPSolver* obj)"
// call: "obj->setLPOptions()"
extern "C"
    void CasADi__StabilizedQPSolver__setLPOptions(CasADi::StabilizedQPSolver* obj);
void CasADi__StabilizedQPSolver__setLPOptions(CasADi::StabilizedQPSolver* obj){

    obj->setLPOptions();
}


// ================== Normal method: "generateNativeCode" ===============
// class: "CasADi::StabilizedQPSolver"
// cppName: "CasADi::StabilizedQPSolver::generateNativeCode"
// cWrapperName: "CasADi__StabilizedQPSolver__generateNativeCode"
// protoArgs: "(CasADi::StabilizedQPSolver* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__StabilizedQPSolver__generateNativeCode(CasADi::StabilizedQPSolver* obj, std::string* x0)"
// call: "obj->generateNativeCode(x0_)"
extern "C"
    void CasADi__StabilizedQPSolver__generateNativeCode(CasADi::StabilizedQPSolver* obj, std::string* x0);
void CasADi__StabilizedQPSolver__generateNativeCode(CasADi::StabilizedQPSolver* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->generateNativeCode(x0_);
}


// ================== Constructor method: "StabilizedQPSolver" ===============
// class: "CasADi::StabilizedQPSolver"
// cppName: "CasADi::StabilizedQPSolver"
// cWrapperName: "CasADi__StabilizedQPSolver__StabilizedQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass StabilizedQPSolver
// cWrapperRetType: "CasADi::StabilizedQPSolver*"
// proto: "CasADi::StabilizedQPSolver* CasADi__StabilizedQPSolver__StabilizedQPSolver()"
// call: "CasADi::StabilizedQPSolver()"
extern "C"
    CasADi::StabilizedQPSolver* CasADi__StabilizedQPSolver__StabilizedQPSolver();
CasADi::StabilizedQPSolver* CasADi__StabilizedQPSolver__StabilizedQPSolver(){

    return WrapReturn< CasADi::StabilizedQPSolver*, CasADi::StabilizedQPSolver >::wrapReturn( CasADi::StabilizedQPSolver() );
}


// ================== delete CasadiClass SymbolicNLP===============
// classType: CasadiClass 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: "(CasADi::SymbolicNLP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicNLP__parseNL(CasADi::SymbolicNLP* obj, std::string* x0)"
// call: "obj->parseNL(x0_)"
extern "C"
    void CasADi__SymbolicNLP__parseNL(CasADi::SymbolicNLP* obj, std::string* x0);
void CasADi__SymbolicNLP__parseNL(CasADi::SymbolicNLP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->parseNL(x0_);
}


// ================== delete CasadiClass CSparse===============
// classType: CasadiClass CSparse
extern "C"
    void delete_CasADi__CSparse(CasADi::CSparse* obj);
void delete_CasADi__CSparse(CasADi::CSparse* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::CSparse"
// cppName: "CasADi::CSparse::checkNode"
// cWrapperName: "CasADi__CSparse__checkNode"
// protoArgs: "(CasADi::CSparse* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CSparse__checkNode(CasADi::CSparse* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__CSparse__checkNode(CasADi::CSparse* obj);
int CasADi__CSparse__checkNode(CasADi::CSparse* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::CSparse"
// cppName: "CasADi::CSparse::creator"
// cWrapperName: "CasADi__CSparse__creator"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__CSparse__creator(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::CSparse::creator(x0_, x1_)"
extern "C"
    CasADi::LinearSolver* CasADi__CSparse__creator(CasADi::Sparsity* x0, int x1);
CasADi::LinearSolver* CasADi__CSparse__creator(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( CasADi::CSparse::creator(x0_, x1_) );
}


// ================== Constructor method: "CSparse" ===============
// class: "CasADi::CSparse"
// cppName: "CasADi::CSparse"
// cWrapperName: "CasADi__CSparse__CSparse"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass CSparse
// cWrapperRetType: "CasADi::CSparse*"
// proto: "CasADi::CSparse* CasADi__CSparse__CSparse()"
// call: "CasADi::CSparse()"
extern "C"
    CasADi::CSparse* CasADi__CSparse__CSparse();
CasADi::CSparse* CasADi__CSparse__CSparse(){

    return WrapReturn< CasADi::CSparse*, CasADi::CSparse >::wrapReturn( CasADi::CSparse() );
}


// ================== Constructor method: "CSparse'" ===============
// class: "CasADi::CSparse"
// cppName: "CasADi::CSparse"
// cWrapperName: "CasADi__CSparse__CSparse_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass CSparse
// cWrapperRetType: "CasADi::CSparse*"
// proto: "CasADi::CSparse* CasADi__CSparse__CSparse_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::CSparse(x0_, x1_)"
extern "C"
    CasADi::CSparse* CasADi__CSparse__CSparse_TIC(CasADi::Sparsity* x0, int x1);
CasADi::CSparse* CasADi__CSparse__CSparse_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::CSparse*, CasADi::CSparse >::wrapReturn( CasADi::CSparse(x0_, x1_) );
}


// ================== Constructor method: "CSparse''" ===============
// class: "CasADi::CSparse"
// cppName: "CasADi::CSparse"
// cWrapperName: "CasADi__CSparse__CSparse_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass CSparse
// cWrapperRetType: "CasADi::CSparse*"
// proto: "CasADi::CSparse* CasADi__CSparse__CSparse_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::CSparse(x0_)"
extern "C"
    CasADi::CSparse* CasADi__CSparse__CSparse_TIC_TIC(CasADi::Sparsity* x0);
CasADi::CSparse* CasADi__CSparse__CSparse_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::CSparse*, CasADi::CSparse >::wrapReturn( CasADi::CSparse(x0_) );
}


// ================== delete CasadiClass PrintableObject===============
// classType: CasadiClass PrintableObject
extern "C"
    void delete_CasADi__PrintableObject(CasADi::PrintableObject* obj);
void delete_CasADi__PrintableObject(CasADi::PrintableObject* obj){
    delete obj;
}

// ================== Normal method: "getRepresentation" ===============
// class: "CasADi::PrintableObject"
// cppName: "CasADi::PrintableObject::getRepresentation"
// cWrapperName: "CasADi__PrintableObject__getRepresentation"
// protoArgs: "(CasADi::PrintableObject* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__PrintableObject__getRepresentation(CasADi::PrintableObject* obj)"
// call: "obj->getRepresentation()"
extern "C"
    std::string* CasADi__PrintableObject__getRepresentation(CasADi::PrintableObject* obj);
std::string* CasADi__PrintableObject__getRepresentation(CasADi::PrintableObject* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getRepresentation() );
}


// ================== Normal method: "getDescription" ===============
// class: "CasADi::PrintableObject"
// cppName: "CasADi::PrintableObject::getDescription"
// cWrapperName: "CasADi__PrintableObject__getDescription"
// protoArgs: "(CasADi::PrintableObject* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__PrintableObject__getDescription(CasADi::PrintableObject* obj)"
// call: "obj->getDescription()"
extern "C"
    std::string* CasADi__PrintableObject__getDescription(CasADi::PrintableObject* obj);
std::string* CasADi__PrintableObject__getDescription(CasADi::PrintableObject* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getDescription() );
}


// ================== delete CasadiClass ExpDMatrix===============
// classType: CasadiClass ExpDMatrix
extern "C"
    void delete_CasADi__GenericExpression_CasADi__Matrix_double__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj);
void delete_CasADi__GenericExpression_CasADi__Matrix_double__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj){
    delete obj;
}

// ================== Normal method: "__mldivide__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__mldivide__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______mldivide__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______mldivide__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__mldivide__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______mldivide__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______mldivide__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__mldivide__(x0_) );
}


// ================== Normal method: "__gt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__gt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______gt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______gt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__gt__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______gt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______gt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__gt__(x0_) );
}


// ================== Normal method: "__ge__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__ge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______ge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______ge__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__ge__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______ge__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______ge__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__ge__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__truediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______truediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______truediv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______truediv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______truediv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__radd__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__radd__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______radd__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______radd__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__radd__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______radd__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______radd__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__radd__(x0_) );
}


// ================== Normal method: "__rsub__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rsub__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rsub__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rsub__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rsub__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rsub__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rsub__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rsub__(x0_) );
}


// ================== Normal method: "__rmul__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rmul__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rmul__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rmul__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rmul__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rmul__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rmul__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rmul__(x0_) );
}


// ================== Normal method: "__rdiv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rdiv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rdiv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rdiv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rdiv__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rdiv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rdiv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rdiv__(x0_) );
}


// ================== Normal method: "__rlt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rlt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rlt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rlt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rlt__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rlt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rlt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rlt__(x0_) );
}


// ================== Normal method: "__rle__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rle__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rle__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rle__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rle__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rle__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rle__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rle__(x0_) );
}


// ================== Normal method: "__rgt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rgt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rgt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rgt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rgt__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rgt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rgt__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rgt__(x0_) );
}


// ================== Normal method: "__rge__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rge__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rge__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rge__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rge__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rge__(x0_) );
}


// ================== Normal method: "__req__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__req__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______req__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______req__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__req__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______req__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______req__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__req__(x0_) );
}


// ================== Normal method: "__rne__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rne__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rne__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rne__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rne__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rne__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rne__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rne__(x0_) );
}


// ================== Normal method: "__rtruediv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< double > >::__rtruediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_double______rtruediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__rtruediv__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__GenericExpression_CasADi__Matrix_double______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__rtruediv__(x0_) );
}


// ================== delete CasadiClass QCQPSolver===============
// classType: CasadiClass QCQPSolver
extern "C"
    void delete_CasADi__QCQPSolver(CasADi::QCQPSolver* obj);
void delete_CasADi__QCQPSolver(CasADi::QCQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::QCQPSolver"
// cppName: "CasADi::QCQPSolver::checkNode"
// cWrapperName: "CasADi__QCQPSolver__checkNode"
// protoArgs: "(CasADi::QCQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__QCQPSolver__checkNode(CasADi::QCQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__QCQPSolver__checkNode(CasADi::QCQPSolver* obj);
int CasADi__QCQPSolver__checkNode(CasADi::QCQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "setQPOptions" ===============
// class: "CasADi::QCQPSolver"
// cppName: "CasADi::QCQPSolver::setQPOptions"
// cWrapperName: "CasADi__QCQPSolver__setQPOptions"
// protoArgs: "(CasADi::QCQPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__QCQPSolver__setQPOptions(CasADi::QCQPSolver* obj)"
// call: "obj->setQPOptions()"
extern "C"
    void CasADi__QCQPSolver__setQPOptions(CasADi::QCQPSolver* obj);
void CasADi__QCQPSolver__setQPOptions(CasADi::QCQPSolver* obj){

    obj->setQPOptions();
}


// ================== Constructor method: "QCQPSolver" ===============
// class: "CasADi::QCQPSolver"
// cppName: "CasADi::QCQPSolver"
// cWrapperName: "CasADi__QCQPSolver__QCQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass QCQPSolver
// cWrapperRetType: "CasADi::QCQPSolver*"
// proto: "CasADi::QCQPSolver* CasADi__QCQPSolver__QCQPSolver()"
// call: "CasADi::QCQPSolver()"
extern "C"
    CasADi::QCQPSolver* CasADi__QCQPSolver__QCQPSolver();
CasADi::QCQPSolver* CasADi__QCQPSolver__QCQPSolver(){

    return WrapReturn< CasADi::QCQPSolver*, CasADi::QCQPSolver >::wrapReturn( CasADi::QCQPSolver() );
}


// ================== delete CasadiClass NLPSolver===============
// classType: CasadiClass NLPSolver
extern "C"
    void delete_CasADi__NLPSolver(CasADi::NLPSolver* obj);
void delete_CasADi__NLPSolver(CasADi::NLPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::checkNode"
// cWrapperName: "CasADi__NLPSolver__checkNode"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__NLPSolver__checkNode(CasADi::NLPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__NLPSolver__checkNode(CasADi::NLPSolver* obj);
int CasADi__NLPSolver__checkNode(CasADi::NLPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "reportConstraints'" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::reportConstraints'"
// cWrapperName: "CasADi__NLPSolver__reportConstraints_TIC"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__NLPSolver__reportConstraints_TIC(CasADi::NLPSolver* obj)"
// call: "obj->reportConstraints()"
extern "C"
    void CasADi__NLPSolver__reportConstraints_TIC(CasADi::NLPSolver* obj);
void CasADi__NLPSolver__reportConstraints_TIC(CasADi::NLPSolver* obj){

    obj->reportConstraints();
}


// ================== Normal method: "getReportConstraints" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::getReportConstraints"
// cWrapperName: "CasADi__NLPSolver__getReportConstraints"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__NLPSolver__getReportConstraints(CasADi::NLPSolver* obj)"
// call: "obj->getReportConstraints()"
extern "C"
    std::string* CasADi__NLPSolver__getReportConstraints(CasADi::NLPSolver* obj);
std::string* CasADi__NLPSolver__getReportConstraints(CasADi::NLPSolver* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getReportConstraints() );
}


// ================== Normal method: "setQPOptions" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::setQPOptions"
// cWrapperName: "CasADi__NLPSolver__setQPOptions"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__NLPSolver__setQPOptions(CasADi::NLPSolver* obj)"
// call: "obj->setQPOptions()"
extern "C"
    void CasADi__NLPSolver__setQPOptions(CasADi::NLPSolver* obj);
void CasADi__NLPSolver__setQPOptions(CasADi::NLPSolver* obj){

    obj->setQPOptions();
}


// ================== Normal method: "nlp" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::nlp"
// cWrapperName: "CasADi__NLPSolver__nlp"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__NLPSolver__nlp(CasADi::NLPSolver* obj)"
// call: "obj->nlp()"
extern "C"
    CasADi::Function* CasADi__NLPSolver__nlp(CasADi::NLPSolver* obj);
CasADi::Function* CasADi__NLPSolver__nlp(CasADi::NLPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->nlp() );
}


// ================== Normal method: "gradF" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::gradF"
// cWrapperName: "CasADi__NLPSolver__gradF"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__NLPSolver__gradF(CasADi::NLPSolver* obj)"
// call: "obj->gradF()"
extern "C"
    CasADi::Function* CasADi__NLPSolver__gradF(CasADi::NLPSolver* obj);
CasADi::Function* CasADi__NLPSolver__gradF(CasADi::NLPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradF() );
}


// ================== Normal method: "jacG" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::jacG"
// cWrapperName: "CasADi__NLPSolver__jacG"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__NLPSolver__jacG(CasADi::NLPSolver* obj)"
// call: "obj->jacG()"
extern "C"
    CasADi::Function* CasADi__NLPSolver__jacG(CasADi::NLPSolver* obj);
CasADi::Function* CasADi__NLPSolver__jacG(CasADi::NLPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacG() );
}


// ================== Normal method: "hessLag" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::hessLag"
// cWrapperName: "CasADi__NLPSolver__hessLag"
// protoArgs: "(CasADi::NLPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__NLPSolver__hessLag(CasADi::NLPSolver* obj)"
// call: "obj->hessLag()"
extern "C"
    CasADi::Function* CasADi__NLPSolver__hessLag(CasADi::NLPSolver* obj);
CasADi::Function* CasADi__NLPSolver__hessLag(CasADi::NLPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessLag() );
}


// ================== Static method: "joinFG" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver::joinFG"
// cWrapperName: "CasADi__NLPSolver__joinFG"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__NLPSolver__joinFG(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::NLPSolver::joinFG(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__NLPSolver__joinFG(CasADi::Function* x0, CasADi::Function* x1);
CasADi::Function* CasADi__NLPSolver__joinFG(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function x0_ = Marshaling<CasADi::Function,CasADi::Function*>::marshal(x0);
    CasADi::Function x1_ = Marshaling<CasADi::Function,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( CasADi::NLPSolver::joinFG(x0_, x1_) );
}


// ================== Constructor method: "NLPSolver" ===============
// class: "CasADi::NLPSolver"
// cppName: "CasADi::NLPSolver"
// cWrapperName: "CasADi__NLPSolver__NLPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__NLPSolver__NLPSolver()"
// call: "CasADi::NLPSolver()"
extern "C"
    CasADi::NLPSolver* CasADi__NLPSolver__NLPSolver();
CasADi::NLPSolver* CasADi__NLPSolver__NLPSolver(){

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( CasADi::NLPSolver() );
}


// ================== delete CasadiClass GenericType===============
// classType: CasadiClass GenericType
extern "C"
    void delete_CasADi__GenericType(CasADi::GenericType* obj);
void delete_CasADi__GenericType(CasADi::GenericType* obj){
    delete obj;
}

// ================== Static method: "get_type_description" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::get_type_description"
// cWrapperName: "CasADi__GenericType__get_type_description"
// protoArgs: "(CasADi::opt_type const * x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericType__get_type_description(CasADi::opt_type const * x0)"
// call: "CasADi::GenericType::get_type_description(x0_)"
extern "C"
    std::string* CasADi__GenericType__get_type_description(CasADi::opt_type const * x0);
std::string* CasADi__GenericType__get_type_description(CasADi::opt_type const * x0){
    CasADi::opt_type const & x0_ = Marshaling<CasADi::opt_type const &,CasADi::opt_type const *>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::GenericType::get_type_description(x0_) );
}


// ================== Normal method: "get_description" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::get_description"
// cWrapperName: "CasADi__GenericType__get_description"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericType__get_description(CasADi::GenericType* obj)"
// call: "obj->get_description()"
extern "C"
    std::string* CasADi__GenericType__get_description(CasADi::GenericType* obj);
std::string* CasADi__GenericType__get_description(CasADi::GenericType* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->get_description() );
}


// ================== Static method: "from_type" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::from_type"
// cWrapperName: "CasADi__GenericType__from_type"
// protoArgs: "(CasADi::opt_type x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__from_type(CasADi::opt_type x0)"
// call: "CasADi::GenericType::from_type(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__from_type(CasADi::opt_type x0);
CasADi::GenericType* CasADi__GenericType__from_type(CasADi::opt_type x0){
    CasADi::opt_type x0_ = Marshaling<CasADi::opt_type,CasADi::opt_type>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType::from_type(x0_) );
}


// ================== Normal method: "getType" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::getType"
// cWrapperName: "CasADi__GenericType__getType"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CasadiEnum Opt_type
// cWrapperRetType: "CasADi::opt_type"
// proto: "CasADi::opt_type CasADi__GenericType__getType(CasADi::GenericType* obj)"
// call: "obj->getType()"
extern "C"
    CasADi::opt_type CasADi__GenericType__getType(CasADi::GenericType* obj);
CasADi::opt_type CasADi__GenericType__getType(CasADi::GenericType* obj){

    return WrapReturn< CasADi::opt_type, CasADi::opt_type >::wrapReturn( obj->getType() );
}


// ================== Normal method: "can_cast_to" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::can_cast_to"
// cWrapperName: "CasADi__GenericType__can_cast_to"
// protoArgs: "(CasADi::GenericType* obj, CasADi::opt_type x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0)"
// call: "obj->can_cast_to(x0_)"
extern "C"
    int CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0);
int CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0){
    CasADi::opt_type x0_ = Marshaling<CasADi::opt_type,CasADi::opt_type>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->can_cast_to(x0_) );
}


// ================== Normal method: "can_cast_to'" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::can_cast_to'"
// cWrapperName: "CasADi__GenericType__can_cast_to_TIC"
// protoArgs: "(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// call: "obj->can_cast_to(x0_)"
extern "C"
    int CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0);
int CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0){
    CasADi::GenericType const & x0_ = Marshaling<CasADi::GenericType const &,CasADi::GenericType*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->can_cast_to(x0_) );
}


// ================== Normal method: "isBool" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isBool"
// cWrapperName: "CasADi__GenericType__isBool"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isBool(CasADi::GenericType* obj)"
// call: "obj->isBool()"
extern "C"
    int CasADi__GenericType__isBool(CasADi::GenericType* obj);
int CasADi__GenericType__isBool(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isBool() );
}


// ================== Normal method: "isInt" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isInt"
// cWrapperName: "CasADi__GenericType__isInt"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isInt(CasADi::GenericType* obj)"
// call: "obj->isInt()"
extern "C"
    int CasADi__GenericType__isInt(CasADi::GenericType* obj);
int CasADi__GenericType__isInt(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInt() );
}


// ================== Normal method: "isDouble" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isDouble"
// cWrapperName: "CasADi__GenericType__isDouble"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isDouble(CasADi::GenericType* obj)"
// call: "obj->isDouble()"
extern "C"
    int CasADi__GenericType__isDouble(CasADi::GenericType* obj);
int CasADi__GenericType__isDouble(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDouble() );
}


// ================== Normal method: "isString" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isString"
// cWrapperName: "CasADi__GenericType__isString"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isString(CasADi::GenericType* obj)"
// call: "obj->isString()"
extern "C"
    int CasADi__GenericType__isString(CasADi::GenericType* obj);
int CasADi__GenericType__isString(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isString() );
}


// ================== Normal method: "isEmptyVector" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isEmptyVector"
// cWrapperName: "CasADi__GenericType__isEmptyVector"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isEmptyVector(CasADi::GenericType* obj)"
// call: "obj->isEmptyVector()"
extern "C"
    int CasADi__GenericType__isEmptyVector(CasADi::GenericType* obj);
int CasADi__GenericType__isEmptyVector(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEmptyVector() );
}


// ================== Normal method: "isIntVector" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isIntVector"
// cWrapperName: "CasADi__GenericType__isIntVector"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isIntVector(CasADi::GenericType* obj)"
// call: "obj->isIntVector()"
extern "C"
    int CasADi__GenericType__isIntVector(CasADi::GenericType* obj);
int CasADi__GenericType__isIntVector(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isIntVector() );
}


// ================== Normal method: "isDoubleVector" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isDoubleVector"
// cWrapperName: "CasADi__GenericType__isDoubleVector"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isDoubleVector(CasADi::GenericType* obj)"
// call: "obj->isDoubleVector()"
extern "C"
    int CasADi__GenericType__isDoubleVector(CasADi::GenericType* obj);
int CasADi__GenericType__isDoubleVector(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDoubleVector() );
}


// ================== Normal method: "isStringVector" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isStringVector"
// cWrapperName: "CasADi__GenericType__isStringVector"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isStringVector(CasADi::GenericType* obj)"
// call: "obj->isStringVector()"
extern "C"
    int CasADi__GenericType__isStringVector(CasADi::GenericType* obj);
int CasADi__GenericType__isStringVector(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isStringVector() );
}


// ================== Normal method: "isSharedObject" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isSharedObject"
// cWrapperName: "CasADi__GenericType__isSharedObject"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isSharedObject(CasADi::GenericType* obj)"
// call: "obj->isSharedObject()"
extern "C"
    int CasADi__GenericType__isSharedObject(CasADi::GenericType* obj);
int CasADi__GenericType__isSharedObject(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSharedObject() );
}


// ================== Normal method: "isDictionary" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isDictionary"
// cWrapperName: "CasADi__GenericType__isDictionary"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isDictionary(CasADi::GenericType* obj)"
// call: "obj->isDictionary()"
extern "C"
    int CasADi__GenericType__isDictionary(CasADi::GenericType* obj);
int CasADi__GenericType__isDictionary(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDictionary() );
}


// ================== Normal method: "isFunction" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isFunction"
// cWrapperName: "CasADi__GenericType__isFunction"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__isFunction(CasADi::GenericType* obj)"
// call: "obj->isFunction()"
extern "C"
    int CasADi__GenericType__isFunction(CasADi::GenericType* obj);
int CasADi__GenericType__isFunction(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isFunction() );
}


// ================== Normal method: "toBool" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::toBool"
// cWrapperName: "CasADi__GenericType__toBool"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__toBool(CasADi::GenericType* obj)"
// call: "obj->toBool()"
extern "C"
    int CasADi__GenericType__toBool(CasADi::GenericType* obj);
int CasADi__GenericType__toBool(CasADi::GenericType* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->toBool() );
}


// ================== Normal method: "toInt" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::toInt"
// cWrapperName: "CasADi__GenericType__toInt"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__toInt(CasADi::GenericType* obj)"
// call: "obj->toInt()"
extern "C"
    int CasADi__GenericType__toInt(CasADi::GenericType* obj);
int CasADi__GenericType__toInt(CasADi::GenericType* obj){

    return WrapReturn< int, int >::wrapReturn( obj->toInt() );
}


// ================== Normal method: "toDouble" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::toDouble"
// cWrapperName: "CasADi__GenericType__toDouble"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__GenericType__toDouble(CasADi::GenericType* obj)"
// call: "obj->toDouble()"
extern "C"
    double CasADi__GenericType__toDouble(CasADi::GenericType* obj);
double CasADi__GenericType__toDouble(CasADi::GenericType* obj){

    return WrapReturn< double, double >::wrapReturn( obj->toDouble() );
}


// ================== Normal method: "operator ==" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::operator =="
// cWrapperName: "CasADi__GenericType__operator_equals"
// protoArgs: "(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// call: "obj->operator ==(x0_)"
extern "C"
    int CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0);
int CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0){
    CasADi::GenericType const & x0_ = Marshaling<CasADi::GenericType const &,CasADi::GenericType*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->operator ==(x0_) );
}


// ================== Normal method: "operator !=" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::operator !="
// cWrapperName: "CasADi__GenericType__operator_nequals"
// protoArgs: "(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// call: "obj->operator !=(x0_)"
extern "C"
    int CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0);
int CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0){
    CasADi::GenericType const & x0_ = Marshaling<CasADi::GenericType const &,CasADi::GenericType*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->operator !=(x0_) );
}


// ================== Constructor method: "GenericType" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType()"
// call: "CasADi::GenericType()"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType();
CasADi::GenericType* CasADi__GenericType__GenericType(){

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType() );
}


// ================== Constructor method: "GenericType'" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC(int x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC(int x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC(int x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC(int x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType'''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC(double x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC(double x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC(std::string* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC(std::string* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType'''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0){
    std::vector< bool > x0_ = Marshaling<std::vector< bool >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType'''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType''''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< std::string* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< std::string* >* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< std::string* >* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< std::string* >* x0){
    std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType'''''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType''''''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SharedObject* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SharedObject* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SharedObject* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SharedObject* x0){
    CasADi::SharedObject const & x0_ = Marshaling<CasADi::SharedObject const &,CasADi::SharedObject*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType'''''''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::DerivativeGenerator* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::DerivativeGenerator* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::DerivativeGenerator* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::DerivativeGenerator* x0){
    CasADi::DerivativeGenerator const & x0_ = Marshaling<CasADi::DerivativeGenerator const &,CasADi::DerivativeGenerator*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType''''''''''''" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Callback* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Callback* x0)"
// call: "CasADi::GenericType(x0_)"
extern "C"
    CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Callback* x0);
CasADi::GenericType* CasADi__GenericType__GenericType_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Callback* x0){
    CasADi::Callback const & x0_ = Marshaling<CasADi::Callback const &,CasADi::Callback*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( CasADi::GenericType(x0_) );
}


// ================== delete CasadiClass NLPQPSolver===============
// classType: CasadiClass NLPQPSolver
extern "C"
    void delete_CasADi__NLPQPSolver(CasADi::NLPQPSolver* obj);
void delete_CasADi__NLPQPSolver(CasADi::NLPQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::NLPQPSolver"
// cppName: "CasADi::NLPQPSolver::checkNode"
// cWrapperName: "CasADi__NLPQPSolver__checkNode"
// protoArgs: "(CasADi::NLPQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__NLPQPSolver__checkNode(CasADi::NLPQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__NLPQPSolver__checkNode(CasADi::NLPQPSolver* obj);
int CasADi__NLPQPSolver__checkNode(CasADi::NLPQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::NLPQPSolver"
// cppName: "CasADi::NLPQPSolver::creator"
// cWrapperName: "CasADi__NLPQPSolver__creator"
// protoArgs: "(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QPSolver
// cWrapperRetType: "CasADi::QPSolver*"
// proto: "CasADi::QPSolver* CasADi__NLPQPSolver__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::NLPQPSolver::creator(x0_)"
extern "C"
    CasADi::QPSolver* CasADi__NLPQPSolver__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::QPSolver* CasADi__NLPQPSolver__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::QPSolver*, CasADi::QPSolver >::wrapReturn( CasADi::NLPQPSolver::creator(x0_) );
}


// ================== Constructor method: "NLPQPSolver" ===============
// class: "CasADi::NLPQPSolver"
// cppName: "CasADi::NLPQPSolver"
// cWrapperName: "CasADi__NLPQPSolver__NLPQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass NLPQPSolver
// cWrapperRetType: "CasADi::NLPQPSolver*"
// proto: "CasADi::NLPQPSolver* CasADi__NLPQPSolver__NLPQPSolver()"
// call: "CasADi::NLPQPSolver()"
extern "C"
    CasADi::NLPQPSolver* CasADi__NLPQPSolver__NLPQPSolver();
CasADi::NLPQPSolver* CasADi__NLPQPSolver__NLPQPSolver(){

    return WrapReturn< CasADi::NLPQPSolver*, CasADi::NLPQPSolver >::wrapReturn( CasADi::NLPQPSolver() );
}


// ================== Constructor method: "NLPQPSolver'" ===============
// class: "CasADi::NLPQPSolver"
// cppName: "CasADi::NLPQPSolver"
// cWrapperName: "CasADi__NLPQPSolver__NLPQPSolver_TIC"
// protoArgs: "(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass NLPQPSolver
// cWrapperRetType: "CasADi::NLPQPSolver*"
// proto: "CasADi::NLPQPSolver* CasADi__NLPQPSolver__NLPQPSolver_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::NLPQPSolver(x0_)"
extern "C"
    CasADi::NLPQPSolver* CasADi__NLPQPSolver__NLPQPSolver_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::NLPQPSolver* CasADi__NLPQPSolver__NLPQPSolver_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::NLPQPSolver*, CasADi::NLPQPSolver >::wrapReturn( CasADi::NLPQPSolver(x0_) );
}


// ================== delete CasadiClass Variable===============
// classType: CasadiClass Variable
extern "C"
    void delete_CasADi__Variable(CasADi::Variable* obj);
void delete_CasADi__Variable(CasADi::Variable* obj){
    delete obj;
}

// ================== Normal method: "name" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable::name"
// cWrapperName: "CasADi__Variable__name"
// protoArgs: "(CasADi::Variable* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Variable__name(CasADi::Variable* obj)"
// call: "obj->name()"
extern "C"
    std::string* CasADi__Variable__name(CasADi::Variable* obj);
std::string* CasADi__Variable__name(CasADi::Variable* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->name() );
}


// ================== Normal method: "setName" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable::setName"
// cWrapperName: "CasADi__Variable__setName"
// protoArgs: "(CasADi::Variable* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Variable__setName(CasADi::Variable* obj, std::string* x0)"
// call: "obj->setName(x0_)"
extern "C"
    void CasADi__Variable__setName(CasADi::Variable* obj, std::string* x0);
void CasADi__Variable__setName(CasADi::Variable* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->setName(x0_);
}


// ================== Normal method: "atTime" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable::atTime"
// cWrapperName: "CasADi__Variable__atTime"
// protoArgs: "(CasADi::Variable* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Variable__atTime(CasADi::Variable* obj, double x0, int x1)"
// call: "obj->atTime(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__Variable__atTime(CasADi::Variable* obj, double x0, int x1);
CasADi::SXElement* CasADi__Variable__atTime(CasADi::Variable* obj, double x0, int x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->atTime(x0_, x1_) );
}


// ================== Normal method: "atTime'" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable::atTime'"
// cWrapperName: "CasADi__Variable__atTime_TIC"
// protoArgs: "(CasADi::Variable* obj, double x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Variable__atTime_TIC(CasADi::Variable* obj, double x0)"
// call: "obj->atTime(x0_)"
extern "C"
    CasADi::SXElement* CasADi__Variable__atTime_TIC(CasADi::Variable* obj, double x0);
CasADi::SXElement* CasADi__Variable__atTime_TIC(CasADi::Variable* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->atTime(x0_) );
}


// ================== Normal method: "atTime''" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable::atTime''"
// cWrapperName: "CasADi__Variable__atTime_TIC_TIC"
// protoArgs: "(CasADi::Variable* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Variable__atTime_TIC_TIC(CasADi::Variable* obj, double x0, int x1)"
// call: "obj->atTime(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__Variable__atTime_TIC_TIC(CasADi::Variable* obj, double x0, int x1);
CasADi::SXElement* CasADi__Variable__atTime_TIC_TIC(CasADi::Variable* obj, double x0, int x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->atTime(x0_, x1_) );
}


// ================== Normal method: "atTime'''" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable::atTime'''"
// cWrapperName: "CasADi__Variable__atTime_TIC_TIC_TIC"
// protoArgs: "(CasADi::Variable* obj, double x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Variable__atTime_TIC_TIC_TIC(CasADi::Variable* obj, double x0)"
// call: "obj->atTime(x0_)"
extern "C"
    CasADi::SXElement* CasADi__Variable__atTime_TIC_TIC_TIC(CasADi::Variable* obj, double x0);
CasADi::SXElement* CasADi__Variable__atTime_TIC_TIC_TIC(CasADi::Variable* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->atTime(x0_) );
}


// ================== Constructor method: "Variable" ===============
// class: "CasADi::Variable"
// cppName: "CasADi::Variable"
// cWrapperName: "CasADi__Variable__Variable"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Variable
// cWrapperRetType: "CasADi::Variable*"
// proto: "CasADi::Variable* CasADi__Variable__Variable()"
// call: "CasADi::Variable()"
extern "C"
    CasADi::Variable* CasADi__Variable__Variable();
CasADi::Variable* CasADi__Variable__Variable(){

    return WrapReturn< CasADi::Variable*, CasADi::Variable >::wrapReturn( CasADi::Variable() );
}


// ================== delete CasadiClass LPStructure===============
// classType: CasadiClass LPStructure
extern "C"
    void delete_CasADi__LPStructIOSchemeVector_CasADi__Sparsity_(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* obj);
void delete_CasADi__LPStructIOSchemeVector_CasADi__Sparsity_(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* obj){
    delete obj;
}

// ================== Constructor method: "LPStructure" ===============
// class: "CasADi::LPStructIOSchemeVector< CasADi::Sparsity >"
// cppName: "CasADi::LPStructIOSchemeVector< CasADi::Sparsity >"
// cWrapperName: "CasADi__LPStructIOSchemeVector_CasADi__Sparsity___LPStructure"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass LPStructure
// cWrapperRetType: "CasADi::LPStructIOSchemeVector< CasADi::Sparsity >*"
// proto: "CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* CasADi__LPStructIOSchemeVector_CasADi__Sparsity___LPStructure(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::LPStructIOSchemeVector< CasADi::Sparsity >(x0_)"
extern "C"
    CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* CasADi__LPStructIOSchemeVector_CasADi__Sparsity___LPStructure(std::vector< CasADi::Sparsity* >* x0);
CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* CasADi__LPStructIOSchemeVector_CasADi__Sparsity___LPStructure(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::LPStructIOSchemeVector< CasADi::Sparsity >*, CasADi::LPStructIOSchemeVector< CasADi::Sparsity > >::wrapReturn( CasADi::LPStructIOSchemeVector< CasADi::Sparsity >(x0_) );
}


// ================== delete CasadiClass ImplicitFixedStepIntegrator===============
// classType: CasadiClass ImplicitFixedStepIntegrator
extern "C"
    void delete_CasADi__ImplicitFixedStepIntegrator(CasADi::ImplicitFixedStepIntegrator* obj);
void delete_CasADi__ImplicitFixedStepIntegrator(CasADi::ImplicitFixedStepIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::ImplicitFixedStepIntegrator"
// cppName: "CasADi::ImplicitFixedStepIntegrator::checkNode"
// cWrapperName: "CasADi__ImplicitFixedStepIntegrator__checkNode"
// protoArgs: "(CasADi::ImplicitFixedStepIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__ImplicitFixedStepIntegrator__checkNode(CasADi::ImplicitFixedStepIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__ImplicitFixedStepIntegrator__checkNode(CasADi::ImplicitFixedStepIntegrator* obj);
int CasADi__ImplicitFixedStepIntegrator__checkNode(CasADi::ImplicitFixedStepIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "ImplicitFixedStepIntegrator" ===============
// class: "CasADi::ImplicitFixedStepIntegrator"
// cppName: "CasADi::ImplicitFixedStepIntegrator"
// cWrapperName: "CasADi__ImplicitFixedStepIntegrator__ImplicitFixedStepIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass ImplicitFixedStepIntegrator
// cWrapperRetType: "CasADi::ImplicitFixedStepIntegrator*"
// proto: "CasADi::ImplicitFixedStepIntegrator* CasADi__ImplicitFixedStepIntegrator__ImplicitFixedStepIntegrator()"
// call: "CasADi::ImplicitFixedStepIntegrator()"
extern "C"
    CasADi::ImplicitFixedStepIntegrator* CasADi__ImplicitFixedStepIntegrator__ImplicitFixedStepIntegrator();
CasADi::ImplicitFixedStepIntegrator* CasADi__ImplicitFixedStepIntegrator__ImplicitFixedStepIntegrator(){

    return WrapReturn< CasADi::ImplicitFixedStepIntegrator*, CasADi::ImplicitFixedStepIntegrator >::wrapReturn( CasADi::ImplicitFixedStepIntegrator() );
}


// ================== delete CasadiClass CSparseCholesky===============
// classType: CasadiClass CSparseCholesky
extern "C"
    void delete_CasADi__CSparseCholesky(CasADi::CSparseCholesky* obj);
void delete_CasADi__CSparseCholesky(CasADi::CSparseCholesky* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky::checkNode"
// cWrapperName: "CasADi__CSparseCholesky__checkNode"
// protoArgs: "(CasADi::CSparseCholesky* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CSparseCholesky__checkNode(CasADi::CSparseCholesky* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__CSparseCholesky__checkNode(CasADi::CSparseCholesky* obj);
int CasADi__CSparseCholesky__checkNode(CasADi::CSparseCholesky* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getFactorizationSparsity" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky::getFactorizationSparsity"
// cWrapperName: "CasADi__CSparseCholesky__getFactorizationSparsity"
// protoArgs: "(CasADi::CSparseCholesky* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__CSparseCholesky__getFactorizationSparsity(CasADi::CSparseCholesky* obj, int x0)"
// call: "obj->getFactorizationSparsity(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__CSparseCholesky__getFactorizationSparsity(CasADi::CSparseCholesky* obj, int x0);
CasADi::Sparsity* CasADi__CSparseCholesky__getFactorizationSparsity(CasADi::CSparseCholesky* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getFactorizationSparsity(x0_) );
}


// ================== Normal method: "getFactorizationSparsity'" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky::getFactorizationSparsity'"
// cWrapperName: "CasADi__CSparseCholesky__getFactorizationSparsity_TIC"
// protoArgs: "(CasADi::CSparseCholesky* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__CSparseCholesky__getFactorizationSparsity_TIC(CasADi::CSparseCholesky* obj)"
// call: "obj->getFactorizationSparsity()"
extern "C"
    CasADi::Sparsity* CasADi__CSparseCholesky__getFactorizationSparsity_TIC(CasADi::CSparseCholesky* obj);
CasADi::Sparsity* CasADi__CSparseCholesky__getFactorizationSparsity_TIC(CasADi::CSparseCholesky* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getFactorizationSparsity() );
}


// ================== Normal method: "getFactorization" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky::getFactorization"
// cWrapperName: "CasADi__CSparseCholesky__getFactorization"
// protoArgs: "(CasADi::CSparseCholesky* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__CSparseCholesky__getFactorization(CasADi::CSparseCholesky* obj, int x0)"
// call: "obj->getFactorization(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__CSparseCholesky__getFactorization(CasADi::CSparseCholesky* obj, int x0);
CasADi::Matrix< double >* CasADi__CSparseCholesky__getFactorization(CasADi::CSparseCholesky* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getFactorization(x0_) );
}


// ================== Normal method: "getFactorization'" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky::getFactorization'"
// cWrapperName: "CasADi__CSparseCholesky__getFactorization_TIC"
// protoArgs: "(CasADi::CSparseCholesky* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__CSparseCholesky__getFactorization_TIC(CasADi::CSparseCholesky* obj)"
// call: "obj->getFactorization()"
extern "C"
    CasADi::Matrix< double >* CasADi__CSparseCholesky__getFactorization_TIC(CasADi::CSparseCholesky* obj);
CasADi::Matrix< double >* CasADi__CSparseCholesky__getFactorization_TIC(CasADi::CSparseCholesky* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getFactorization() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky::creator"
// cWrapperName: "CasADi__CSparseCholesky__creator"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__CSparseCholesky__creator(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::CSparseCholesky::creator(x0_, x1_)"
extern "C"
    CasADi::LinearSolver* CasADi__CSparseCholesky__creator(CasADi::Sparsity* x0, int x1);
CasADi::LinearSolver* CasADi__CSparseCholesky__creator(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( CasADi::CSparseCholesky::creator(x0_, x1_) );
}


// ================== Constructor method: "CSparseCholesky" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky"
// cWrapperName: "CasADi__CSparseCholesky__CSparseCholesky"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass CSparseCholesky
// cWrapperRetType: "CasADi::CSparseCholesky*"
// proto: "CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky()"
// call: "CasADi::CSparseCholesky()"
extern "C"
    CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky();
CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky(){

    return WrapReturn< CasADi::CSparseCholesky*, CasADi::CSparseCholesky >::wrapReturn( CasADi::CSparseCholesky() );
}


// ================== Constructor method: "CSparseCholesky'" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky"
// cWrapperName: "CasADi__CSparseCholesky__CSparseCholesky_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass CSparseCholesky
// cWrapperRetType: "CasADi::CSparseCholesky*"
// proto: "CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::CSparseCholesky(x0_, x1_)"
extern "C"
    CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky_TIC(CasADi::Sparsity* x0, int x1);
CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::CSparseCholesky*, CasADi::CSparseCholesky >::wrapReturn( CasADi::CSparseCholesky(x0_, x1_) );
}


// ================== Constructor method: "CSparseCholesky''" ===============
// class: "CasADi::CSparseCholesky"
// cppName: "CasADi::CSparseCholesky"
// cWrapperName: "CasADi__CSparseCholesky__CSparseCholesky_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass CSparseCholesky
// cWrapperRetType: "CasADi::CSparseCholesky*"
// proto: "CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::CSparseCholesky(x0_)"
extern "C"
    CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky_TIC_TIC(CasADi::Sparsity* x0);
CasADi::CSparseCholesky* CasADi__CSparseCholesky__CSparseCholesky_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::CSparseCholesky*, CasADi::CSparseCholesky >::wrapReturn( CasADi::CSparseCholesky(x0_) );
}


// ================== delete CasadiClass SDPSOCPSolver===============
// classType: CasadiClass SDPSOCPSolver
extern "C"
    void delete_CasADi__SDPSOCPSolver(CasADi::SDPSOCPSolver* obj);
void delete_CasADi__SDPSOCPSolver(CasADi::SDPSOCPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SDPSOCPSolver"
// cppName: "CasADi::SDPSOCPSolver::checkNode"
// cWrapperName: "CasADi__SDPSOCPSolver__checkNode"
// protoArgs: "(CasADi::SDPSOCPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SDPSOCPSolver__checkNode(CasADi::SDPSOCPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SDPSOCPSolver__checkNode(CasADi::SDPSOCPSolver* obj);
int CasADi__SDPSOCPSolver__checkNode(CasADi::SDPSOCPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SDPSOCPSolver"
// cppName: "CasADi::SDPSOCPSolver::creator"
// cWrapperName: "CasADi__SDPSOCPSolver__creator"
// protoArgs: "(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SOCPSolver
// cWrapperRetType: "CasADi::SOCPSolver*"
// proto: "CasADi::SOCPSolver* CasADi__SDPSOCPSolver__creator(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::SDPSOCPSolver::creator(x0_)"
extern "C"
    CasADi::SOCPSolver* CasADi__SDPSOCPSolver__creator(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::SOCPSolver* CasADi__SDPSOCPSolver__creator(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::SOCPSolver*, CasADi::SOCPSolver >::wrapReturn( CasADi::SDPSOCPSolver::creator(x0_) );
}


// ================== Normal method: "getSolver" ===============
// class: "CasADi::SDPSOCPSolver"
// cppName: "CasADi::SDPSOCPSolver::getSolver"
// cWrapperName: "CasADi__SDPSOCPSolver__getSolver"
// protoArgs: "(CasADi::SDPSOCPSolver* obj)"
// args: "()"
// rettype: CasadiClass SDPSolver
// cWrapperRetType: "CasADi::SDPSolver*"
// proto: "CasADi::SDPSolver* CasADi__SDPSOCPSolver__getSolver(CasADi::SDPSOCPSolver* obj)"
// call: "obj->getSolver()"
extern "C"
    CasADi::SDPSolver* CasADi__SDPSOCPSolver__getSolver(CasADi::SDPSOCPSolver* obj);
CasADi::SDPSolver* CasADi__SDPSOCPSolver__getSolver(CasADi::SDPSOCPSolver* obj){

    return WrapReturn< CasADi::SDPSolver*, CasADi::SDPSolver >::wrapReturn( obj->getSolver() );
}


// ================== Constructor method: "SDPSOCPSolver" ===============
// class: "CasADi::SDPSOCPSolver"
// cppName: "CasADi::SDPSOCPSolver"
// cWrapperName: "CasADi__SDPSOCPSolver__SDPSOCPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SDPSOCPSolver
// cWrapperRetType: "CasADi::SDPSOCPSolver*"
// proto: "CasADi::SDPSOCPSolver* CasADi__SDPSOCPSolver__SDPSOCPSolver()"
// call: "CasADi::SDPSOCPSolver()"
extern "C"
    CasADi::SDPSOCPSolver* CasADi__SDPSOCPSolver__SDPSOCPSolver();
CasADi::SDPSOCPSolver* CasADi__SDPSOCPSolver__SDPSOCPSolver(){

    return WrapReturn< CasADi::SDPSOCPSolver*, CasADi::SDPSOCPSolver >::wrapReturn( CasADi::SDPSOCPSolver() );
}


// ================== Constructor method: "SDPSOCPSolver'" ===============
// class: "CasADi::SDPSOCPSolver"
// cppName: "CasADi::SDPSOCPSolver"
// cWrapperName: "CasADi__SDPSOCPSolver__SDPSOCPSolver_TIC"
// protoArgs: "(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SDPSOCPSolver
// cWrapperRetType: "CasADi::SDPSOCPSolver*"
// proto: "CasADi::SDPSOCPSolver* CasADi__SDPSOCPSolver__SDPSOCPSolver_TIC(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::SDPSOCPSolver(x0_)"
extern "C"
    CasADi::SDPSOCPSolver* CasADi__SDPSOCPSolver__SDPSOCPSolver_TIC(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::SDPSOCPSolver* CasADi__SDPSOCPSolver__SDPSOCPSolver_TIC(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::SDPSOCPSolver*, CasADi::SDPSOCPSolver >::wrapReturn( CasADi::SDPSOCPSolver(x0_) );
}


// ================== delete CasadiClass OptionsFunctionality===============
// classType: CasadiClass OptionsFunctionality
extern "C"
    void delete_CasADi__OptionsFunctionality(CasADi::OptionsFunctionality* obj);
void delete_CasADi__OptionsFunctionality(CasADi::OptionsFunctionality* obj){
    delete obj;
}

// ================== Normal method: "setOption" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::setOption"
// cWrapperName: "CasADi__OptionsFunctionality__setOption"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__OptionsFunctionality__setOption(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1)"
// call: "obj->setOption(x0_, x1_)"
extern "C"
    void CasADi__OptionsFunctionality__setOption(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1);
void CasADi__OptionsFunctionality__setOption(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::GenericType const & x1_ = Marshaling<CasADi::GenericType const &,CasADi::GenericType*>::marshal(x1);

    obj->setOption(x0_, x1_);
}


// ================== Normal method: "getOption" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOption"
// cWrapperName: "CasADi__OptionsFunctionality__getOption"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__OptionsFunctionality__getOption(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOption(x0_)"
extern "C"
    CasADi::GenericType* CasADi__OptionsFunctionality__getOption(CasADi::OptionsFunctionality* obj, std::string* x0);
CasADi::GenericType* CasADi__OptionsFunctionality__getOption(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( obj->getOption(x0_) );
}


// ================== Normal method: "hasOption" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::hasOption"
// cWrapperName: "CasADi__OptionsFunctionality__hasOption"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->hasOption(x0_)"
extern "C"
    int CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0);
int CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->hasOption(x0_) );
}


// ================== Normal method: "hasSetOption" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::hasSetOption"
// cWrapperName: "CasADi__OptionsFunctionality__hasSetOption"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->hasSetOption(x0_)"
extern "C"
    int CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0);
int CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->hasSetOption(x0_) );
}


// ================== Normal method: "printOptions'" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::printOptions'"
// cWrapperName: "CasADi__OptionsFunctionality__printOptions_TIC"
// protoArgs: "(CasADi::OptionsFunctionality* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__OptionsFunctionality__printOptions_TIC(CasADi::OptionsFunctionality* obj)"
// call: "obj->printOptions()"
extern "C"
    void CasADi__OptionsFunctionality__printOptions_TIC(CasADi::OptionsFunctionality* obj);
void CasADi__OptionsFunctionality__printOptions_TIC(CasADi::OptionsFunctionality* obj){

    obj->printOptions();
}


// ================== Normal method: "copyOptions" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::copyOptions"
// cWrapperName: "CasADi__OptionsFunctionality__copyOptions"
// protoArgs: "(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__OptionsFunctionality__copyOptions(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, int x1)"
// call: "obj->copyOptions(x0_, x1_)"
extern "C"
    void CasADi__OptionsFunctionality__copyOptions(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, int x1);
void CasADi__OptionsFunctionality__copyOptions(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, int x1){
    CasADi::OptionsFunctionality const & x0_ = Marshaling<CasADi::OptionsFunctionality const &,CasADi::OptionsFunctionality*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    obj->copyOptions(x0_, x1_);
}


// ================== Normal method: "copyOptions'" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::copyOptions'"
// cWrapperName: "CasADi__OptionsFunctionality__copyOptions_TIC"
// protoArgs: "(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__OptionsFunctionality__copyOptions_TIC(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0)"
// call: "obj->copyOptions(x0_)"
extern "C"
    void CasADi__OptionsFunctionality__copyOptions_TIC(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0);
void CasADi__OptionsFunctionality__copyOptions_TIC(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0){
    CasADi::OptionsFunctionality const & x0_ = Marshaling<CasADi::OptionsFunctionality const &,CasADi::OptionsFunctionality*>::marshal(x0);

    obj->copyOptions(x0_);
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::checkNode"
// cWrapperName: "CasADi__OptionsFunctionality__checkNode"
// protoArgs: "(CasADi::OptionsFunctionality* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__OptionsFunctionality__checkNode(CasADi::OptionsFunctionality* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__OptionsFunctionality__checkNode(CasADi::OptionsFunctionality* obj);
int CasADi__OptionsFunctionality__checkNode(CasADi::OptionsFunctionality* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getOptionNames" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionNames"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionNames"
// protoArgs: "(CasADi::OptionsFunctionality* obj)"
// args: "()"
// rettype: StdVec StdString
// cWrapperRetType: "std::vector< std::string* >*"
// proto: "std::vector< std::string* >* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj)"
// call: "obj->getOptionNames()"
extern "C"
    std::vector< std::string* >* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj);
std::vector< std::string* >* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj){

    return WrapReturn< std::vector< std::string* >*, std::vector< std::string > >::wrapReturn( obj->getOptionNames() );
}


// ================== Normal method: "getOptionDescription" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionDescription"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionDescription"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__OptionsFunctionality__getOptionDescription(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionDescription(x0_)"
extern "C"
    std::string* CasADi__OptionsFunctionality__getOptionDescription(CasADi::OptionsFunctionality* obj, std::string* x0);
std::string* CasADi__OptionsFunctionality__getOptionDescription(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getOptionDescription(x0_) );
}


// ================== Normal method: "getOptionType" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionType"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionType"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiEnum Opt_type
// cWrapperRetType: "CasADi::opt_type"
// proto: "CasADi::opt_type CasADi__OptionsFunctionality__getOptionType(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionType(x0_)"
extern "C"
    CasADi::opt_type CasADi__OptionsFunctionality__getOptionType(CasADi::OptionsFunctionality* obj, std::string* x0);
CasADi::opt_type CasADi__OptionsFunctionality__getOptionType(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::opt_type, CasADi::opt_type >::wrapReturn( obj->getOptionType(x0_) );
}


// ================== Normal method: "getOptionTypeName" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionTypeName"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionTypeName"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__OptionsFunctionality__getOptionTypeName(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionTypeName(x0_)"
extern "C"
    std::string* CasADi__OptionsFunctionality__getOptionTypeName(CasADi::OptionsFunctionality* obj, std::string* x0);
std::string* CasADi__OptionsFunctionality__getOptionTypeName(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getOptionTypeName(x0_) );
}


// ================== Normal method: "getOptionAllowed" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionAllowed"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionAllowed"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass GenericType)
// cWrapperRetType: "std::vector< CasADi::GenericType* >*"
// proto: "std::vector< CasADi::GenericType* >* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionAllowed(x0_)"
extern "C"
    std::vector< CasADi::GenericType* >* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0);
std::vector< CasADi::GenericType* >* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::GenericType* >*, std::vector< CasADi::GenericType > >::wrapReturn( obj->getOptionAllowed(x0_) );
}


// ================== Normal method: "getOptionAllowedIndex" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionAllowedIndex"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionAllowedIndex"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__OptionsFunctionality__getOptionAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionAllowedIndex(x0_)"
extern "C"
    int CasADi__OptionsFunctionality__getOptionAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0);
int CasADi__OptionsFunctionality__getOptionAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->getOptionAllowedIndex(x0_) );
}


// ================== Normal method: "setOptionByAllowedIndex" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::setOptionByAllowedIndex"
// cWrapperName: "CasADi__OptionsFunctionality__setOptionByAllowedIndex"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__OptionsFunctionality__setOptionByAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"
// call: "obj->setOptionByAllowedIndex(x0_, x1_)"
extern "C"
    void CasADi__OptionsFunctionality__setOptionByAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0, int x1);
void CasADi__OptionsFunctionality__setOptionByAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOptionByAllowedIndex(x0_, x1_);
}


// ================== Normal method: "getOptionEnumValue" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionEnumValue"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionEnumValue"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__OptionsFunctionality__getOptionEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionEnumValue(x0_)"
extern "C"
    int CasADi__OptionsFunctionality__getOptionEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0);
int CasADi__OptionsFunctionality__getOptionEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->getOptionEnumValue(x0_) );
}


// ================== Normal method: "setOptionByEnumValue" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::setOptionByEnumValue"
// cWrapperName: "CasADi__OptionsFunctionality__setOptionByEnumValue"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__OptionsFunctionality__setOptionByEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"
// call: "obj->setOptionByEnumValue(x0_, x1_)"
extern "C"
    void CasADi__OptionsFunctionality__setOptionByEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0, int x1);
void CasADi__OptionsFunctionality__setOptionByEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOptionByEnumValue(x0_, x1_);
}


// ================== Normal method: "getOptionDefault" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionDefault"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionDefault"
// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__OptionsFunctionality__getOptionDefault(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->getOptionDefault(x0_)"
extern "C"
    CasADi::GenericType* CasADi__OptionsFunctionality__getOptionDefault(CasADi::OptionsFunctionality* obj, std::string* x0);
CasADi::GenericType* CasADi__OptionsFunctionality__getOptionDefault(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( obj->getOptionDefault(x0_) );
}


// ================== Constructor method: "OptionsFunctionality" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality"
// cWrapperName: "CasADi__OptionsFunctionality__OptionsFunctionality"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass OptionsFunctionality
// cWrapperRetType: "CasADi::OptionsFunctionality*"
// proto: "CasADi::OptionsFunctionality* CasADi__OptionsFunctionality__OptionsFunctionality()"
// call: "CasADi::OptionsFunctionality()"
extern "C"
    CasADi::OptionsFunctionality* CasADi__OptionsFunctionality__OptionsFunctionality();
CasADi::OptionsFunctionality* CasADi__OptionsFunctionality__OptionsFunctionality(){

    return WrapReturn< CasADi::OptionsFunctionality*, CasADi::OptionsFunctionality >::wrapReturn( CasADi::OptionsFunctionality() );
}


// ================== delete CasadiClass OldCollocationIntegrator===============
// classType: CasadiClass OldCollocationIntegrator
extern "C"
    void delete_CasADi__OldCollocationIntegrator(CasADi::OldCollocationIntegrator* obj);
void delete_CasADi__OldCollocationIntegrator(CasADi::OldCollocationIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::OldCollocationIntegrator"
// cppName: "CasADi::OldCollocationIntegrator::checkNode"
// cWrapperName: "CasADi__OldCollocationIntegrator__checkNode"
// protoArgs: "(CasADi::OldCollocationIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__OldCollocationIntegrator__checkNode(CasADi::OldCollocationIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__OldCollocationIntegrator__checkNode(CasADi::OldCollocationIntegrator* obj);
int CasADi__OldCollocationIntegrator__checkNode(CasADi::OldCollocationIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::OldCollocationIntegrator"
// cppName: "CasADi::OldCollocationIntegrator::creator"
// cWrapperName: "CasADi__OldCollocationIntegrator__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__OldCollocationIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::OldCollocationIntegrator::creator(x0_, x1_)"
extern "C"
    CasADi::Integrator* CasADi__OldCollocationIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1);
CasADi::Integrator* CasADi__OldCollocationIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( CasADi::OldCollocationIntegrator::creator(x0_, x1_) );
}


// ================== Constructor method: "OldCollocationIntegrator" ===============
// class: "CasADi::OldCollocationIntegrator"
// cppName: "CasADi::OldCollocationIntegrator"
// cWrapperName: "CasADi__OldCollocationIntegrator__OldCollocationIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass OldCollocationIntegrator
// cWrapperRetType: "CasADi::OldCollocationIntegrator*"
// proto: "CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator()"
// call: "CasADi::OldCollocationIntegrator()"
extern "C"
    CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator();
CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator(){

    return WrapReturn< CasADi::OldCollocationIntegrator*, CasADi::OldCollocationIntegrator >::wrapReturn( CasADi::OldCollocationIntegrator() );
}


// ================== Constructor method: "OldCollocationIntegrator'" ===============
// class: "CasADi::OldCollocationIntegrator"
// cppName: "CasADi::OldCollocationIntegrator"
// cWrapperName: "CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass OldCollocationIntegrator
// cWrapperRetType: "CasADi::OldCollocationIntegrator*"
// proto: "CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::OldCollocationIntegrator(x0_, x1_)"
extern "C"
    CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::OldCollocationIntegrator*, CasADi::OldCollocationIntegrator >::wrapReturn( CasADi::OldCollocationIntegrator(x0_, x1_) );
}


// ================== Constructor method: "OldCollocationIntegrator''" ===============
// class: "CasADi::OldCollocationIntegrator"
// cppName: "CasADi::OldCollocationIntegrator"
// cWrapperName: "CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass OldCollocationIntegrator
// cWrapperRetType: "CasADi::OldCollocationIntegrator*"
// proto: "CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::OldCollocationIntegrator(x0_)"
extern "C"
    CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC_TIC(CasADi::Function* x0);
CasADi::OldCollocationIntegrator* CasADi__OldCollocationIntegrator__OldCollocationIntegrator_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::OldCollocationIntegrator*, CasADi::OldCollocationIntegrator >::wrapReturn( CasADi::OldCollocationIntegrator(x0_) );
}


// ================== delete CasadiClass FixedStepIntegrator===============
// classType: CasadiClass FixedStepIntegrator
extern "C"
    void delete_CasADi__FixedStepIntegrator(CasADi::FixedStepIntegrator* obj);
void delete_CasADi__FixedStepIntegrator(CasADi::FixedStepIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::FixedStepIntegrator"
// cppName: "CasADi::FixedStepIntegrator::checkNode"
// cWrapperName: "CasADi__FixedStepIntegrator__checkNode"
// protoArgs: "(CasADi::FixedStepIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__FixedStepIntegrator__checkNode(CasADi::FixedStepIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__FixedStepIntegrator__checkNode(CasADi::FixedStepIntegrator* obj);
int CasADi__FixedStepIntegrator__checkNode(CasADi::FixedStepIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "FixedStepIntegrator" ===============
// class: "CasADi::FixedStepIntegrator"
// cppName: "CasADi::FixedStepIntegrator"
// cWrapperName: "CasADi__FixedStepIntegrator__FixedStepIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass FixedStepIntegrator
// cWrapperRetType: "CasADi::FixedStepIntegrator*"
// proto: "CasADi::FixedStepIntegrator* CasADi__FixedStepIntegrator__FixedStepIntegrator()"
// call: "CasADi::FixedStepIntegrator()"
extern "C"
    CasADi::FixedStepIntegrator* CasADi__FixedStepIntegrator__FixedStepIntegrator();
CasADi::FixedStepIntegrator* CasADi__FixedStepIntegrator__FixedStepIntegrator(){

    return WrapReturn< CasADi::FixedStepIntegrator*, CasADi::FixedStepIntegrator >::wrapReturn( CasADi::FixedStepIntegrator() );
}


// ================== delete CasadiClass CollocationIntegrator===============
// classType: CasadiClass CollocationIntegrator
extern "C"
    void delete_CasADi__CollocationIntegrator(CasADi::CollocationIntegrator* obj);
void delete_CasADi__CollocationIntegrator(CasADi::CollocationIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::CollocationIntegrator"
// cppName: "CasADi::CollocationIntegrator::checkNode"
// cWrapperName: "CasADi__CollocationIntegrator__checkNode"
// protoArgs: "(CasADi::CollocationIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CollocationIntegrator__checkNode(CasADi::CollocationIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__CollocationIntegrator__checkNode(CasADi::CollocationIntegrator* obj);
int CasADi__CollocationIntegrator__checkNode(CasADi::CollocationIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::CollocationIntegrator"
// cppName: "CasADi::CollocationIntegrator::creator"
// cWrapperName: "CasADi__CollocationIntegrator__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__CollocationIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::CollocationIntegrator::creator(x0_, x1_)"
extern "C"
    CasADi::Integrator* CasADi__CollocationIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1);
CasADi::Integrator* CasADi__CollocationIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( CasADi::CollocationIntegrator::creator(x0_, x1_) );
}


// ================== Constructor method: "CollocationIntegrator" ===============
// class: "CasADi::CollocationIntegrator"
// cppName: "CasADi::CollocationIntegrator"
// cWrapperName: "CasADi__CollocationIntegrator__CollocationIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass CollocationIntegrator
// cWrapperRetType: "CasADi::CollocationIntegrator*"
// proto: "CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator()"
// call: "CasADi::CollocationIntegrator()"
extern "C"
    CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator();
CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator(){

    return WrapReturn< CasADi::CollocationIntegrator*, CasADi::CollocationIntegrator >::wrapReturn( CasADi::CollocationIntegrator() );
}


// ================== Constructor method: "CollocationIntegrator'" ===============
// class: "CasADi::CollocationIntegrator"
// cppName: "CasADi::CollocationIntegrator"
// cWrapperName: "CasADi__CollocationIntegrator__CollocationIntegrator_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass CollocationIntegrator
// cWrapperRetType: "CasADi::CollocationIntegrator*"
// proto: "CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::CollocationIntegrator(x0_, x1_)"
extern "C"
    CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::CollocationIntegrator*, CasADi::CollocationIntegrator >::wrapReturn( CasADi::CollocationIntegrator(x0_, x1_) );
}


// ================== Constructor method: "CollocationIntegrator''" ===============
// class: "CasADi::CollocationIntegrator"
// cppName: "CasADi::CollocationIntegrator"
// cWrapperName: "CasADi__CollocationIntegrator__CollocationIntegrator_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass CollocationIntegrator
// cWrapperRetType: "CasADi::CollocationIntegrator*"
// proto: "CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::CollocationIntegrator(x0_)"
extern "C"
    CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator_TIC_TIC(CasADi::Function* x0);
CasADi::CollocationIntegrator* CasADi__CollocationIntegrator__CollocationIntegrator_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::CollocationIntegrator*, CasADi::CollocationIntegrator >::wrapReturn( CasADi::CollocationIntegrator(x0_) );
}


// ================== delete CasadiClass GenSX===============
// classType: CasadiClass GenSX
extern "C"
    void delete_CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement__(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
void delete_CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement__(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){
    delete obj;
}

// ================== Normal method: "size" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::size"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size() );
}


// ================== Normal method: "sizeL" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sizeL"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeL"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeL(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->sizeL()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeL(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeL(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeL() );
}


// ================== Normal method: "sizeU" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sizeU"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeU"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeU(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->sizeU()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeU(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeU(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeU() );
}


// ================== Normal method: "sizeD" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sizeD"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeD"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeD(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->sizeD()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeD(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sizeD(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeD() );
}


// ================== Normal method: "numel" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::numel"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____numel"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____numel(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____numel(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____numel(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->numel() );
}


// ================== Normal method: "size1" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::size1"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size1"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size1(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size1(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size1(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size1() );
}


// ================== Normal method: "size2" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::size2"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size2"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size2(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size2(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size2(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size2() );
}


// ================== Normal method: "size'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::size'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::SparsityType x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::SparsityType x0)"
// call: "obj->size(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::SparsityType x0);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::SparsityType x0){
    CasADi::SparsityType x0_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->size(x0_) );
}


// ================== Normal method: "dimString" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::dimString"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____dimString"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____dimString(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->dimString()"
extern "C"
    std::string* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____dimString(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
std::string* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____dimString(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->dimString() );
}


// ================== Normal method: "isEmpty" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isEmpty"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0)"
// call: "obj->isEmpty(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty(x0_) );
}


// ================== Normal method: "isEmpty'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isEmpty'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isEmpty()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty() );
}


// ================== Normal method: "isDense" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isDense"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isDense"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isDense(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isDense()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isDense(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isDense(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDense() );
}


// ================== Normal method: "isScalar" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isScalar"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0)"
// call: "obj->isScalar(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar(x0_) );
}


// ================== Normal method: "isScalar'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isScalar'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isScalar()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar() );
}


// ================== Normal method: "isSquare" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isSquare"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isSquare"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isSquare(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isSquare()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isSquare(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isSquare(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSquare() );
}


// ================== Normal method: "isVector" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isVector"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isVector"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isVector(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isVector()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isVector(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isVector(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isVector() );
}


// ================== Normal method: "isTriu" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isTriu"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTriu"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTriu(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isTriu()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTriu(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTriu(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTriu() );
}


// ================== Normal method: "isTril" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::isTril"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTril"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTril(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->isTril()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTril(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____isTril(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTril() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparsityRef"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparsityRef"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj);
CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Static method: "sym" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym"
// protoArgs: "(std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym(std::string* x0, int x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym(std::string* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym(std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC"
// protoArgs: "(std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC(std::string* x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC(std::string* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC(std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_) );
}


// ================== Static method: "sym''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC(std::string* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC(std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_) );
}


// ================== Static method: "sym'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_) );
}


// ================== Static method: "sym''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym'''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (CasadiClass SX))
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym'''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym'''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (CasadiClass SX))
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sym(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "sparse" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse(int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC(int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse(x0_) );
}


// ================== Static method: "sparse''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC_TIC();
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____sparse_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::sparse() );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros(int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros(x0_, x1_) );
}


// ================== Static method: "zeros'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC(int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros(x0_) );
}


// ================== Static method: "zeros''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC();
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros() );
}


// ================== Static method: "zeros'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones(int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones(x0_, x1_) );
}


// ================== Static method: "ones'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC(int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones(x0_) );
}


// ================== Static method: "ones''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC();
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones() );
}


// ================== Static method: "ones'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____ones_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::ones(x0_) );
}


// ================== Normal method: "mul_smart" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >::mul_smart"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____mul_smart"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericMatrix_CasADi__Matrix_CasADi__SXElement____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->mul_smart(x0_, x1_) );
}


// ================== delete CasadiClass IpoptSolver===============
// classType: CasadiClass IpoptSolver
extern "C"
    void delete_CasADi__IpoptSolver(CasADi::IpoptSolver* obj);
void delete_CasADi__IpoptSolver(CasADi::IpoptSolver* obj){
    delete obj;
}

// ================== Normal method: "getReducedHessian" ===============
// class: "CasADi::IpoptSolver"
// cppName: "CasADi::IpoptSolver::getReducedHessian"
// cWrapperName: "CasADi__IpoptSolver__getReducedHessian"
// protoArgs: "(CasADi::IpoptSolver* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IpoptSolver__getReducedHessian(CasADi::IpoptSolver* obj)"
// call: "obj->getReducedHessian()"
extern "C"
    CasADi::Matrix< double >* CasADi__IpoptSolver__getReducedHessian(CasADi::IpoptSolver* obj);
CasADi::Matrix< double >* CasADi__IpoptSolver__getReducedHessian(CasADi::IpoptSolver* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getReducedHessian() );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::IpoptSolver"
// cppName: "CasADi::IpoptSolver::checkNode"
// cWrapperName: "CasADi__IpoptSolver__checkNode"
// protoArgs: "(CasADi::IpoptSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__IpoptSolver__checkNode(CasADi::IpoptSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__IpoptSolver__checkNode(CasADi::IpoptSolver* obj);
int CasADi__IpoptSolver__checkNode(CasADi::IpoptSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::IpoptSolver"
// cppName: "CasADi::IpoptSolver::creator"
// cWrapperName: "CasADi__IpoptSolver__creator"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__IpoptSolver__creator(CasADi::Function* x0)"
// call: "CasADi::IpoptSolver::creator(x0_)"
extern "C"
    CasADi::NLPSolver* CasADi__IpoptSolver__creator(CasADi::Function* x0);
CasADi::NLPSolver* CasADi__IpoptSolver__creator(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( CasADi::IpoptSolver::creator(x0_) );
}


// ================== Constructor method: "IpoptSolver" ===============
// class: "CasADi::IpoptSolver"
// cppName: "CasADi::IpoptSolver"
// cWrapperName: "CasADi__IpoptSolver__IpoptSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IpoptSolver
// cWrapperRetType: "CasADi::IpoptSolver*"
// proto: "CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver()"
// call: "CasADi::IpoptSolver()"
extern "C"
    CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver();
CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver(){

    return WrapReturn< CasADi::IpoptSolver*, CasADi::IpoptSolver >::wrapReturn( CasADi::IpoptSolver() );
}


// ================== Constructor method: "IpoptSolver'" ===============
// class: "CasADi::IpoptSolver"
// cppName: "CasADi::IpoptSolver"
// cWrapperName: "CasADi__IpoptSolver__IpoptSolver_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass IpoptSolver
// cWrapperRetType: "CasADi::IpoptSolver*"
// proto: "CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC(CasADi::Function* x0)"
// call: "CasADi::IpoptSolver(x0_)"
extern "C"
    CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC(CasADi::Function* x0);
CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::IpoptSolver*, CasADi::IpoptSolver >::wrapReturn( CasADi::IpoptSolver(x0_) );
}


// ================== delete CasadiClass DMatrix===============
// classType: CasadiClass DMatrix
extern "C"
    void delete_CasADi__Matrix_double_(CasADi::Matrix< double >* obj);
void delete_CasADi__Matrix_double_(CasADi::Matrix< double >* obj){
    delete obj;
}

// ================== Normal method: "sanityCheck" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sanityCheck"
// cWrapperName: "CasADi__Matrix_double___sanityCheck"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___sanityCheck(CasADi::Matrix< double >* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
extern "C"
    void CasADi__Matrix_double___sanityCheck(CasADi::Matrix< double >* obj, int x0);
void CasADi__Matrix_double___sanityCheck(CasADi::Matrix< double >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
}


// ================== Normal method: "sanityCheck'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sanityCheck'"
// cWrapperName: "CasADi__Matrix_double___sanityCheck_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___sanityCheck_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->sanityCheck()"
extern "C"
    void CasADi__Matrix_double___sanityCheck_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___sanityCheck_TIC(CasADi::Matrix< double >* obj){

    obj->sanityCheck();
}


// ================== Normal method: "at" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::at"
// cWrapperName: "CasADi__Matrix_double___at"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_double___at(CasADi::Matrix< double >* obj, int x0)"
// call: "obj->at(x0_)"
extern "C"
    double CasADi__Matrix_double___at(CasADi::Matrix< double >* obj, int x0);
double CasADi__Matrix_double___at(CasADi::Matrix< double >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( obj->at(x0_) );
}


// ================== Normal method: "elem" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::elem"
// cWrapperName: "CasADi__Matrix_double___elem"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_double___elem(CasADi::Matrix< double >* obj, int x0, int x1)"
// call: "obj->elem(x0_, x1_)"
extern "C"
    double CasADi__Matrix_double___elem(CasADi::Matrix< double >* obj, int x0, int x1);
double CasADi__Matrix_double___elem(CasADi::Matrix< double >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< double, double >::wrapReturn( obj->elem(x0_, x1_) );
}


// ================== Normal method: "elem'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::elem'"
// cWrapperName: "CasADi__Matrix_double___elem_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_double___elem_TIC(CasADi::Matrix< double >* obj, int x0)"
// call: "obj->elem(x0_)"
extern "C"
    double CasADi__Matrix_double___elem_TIC(CasADi::Matrix< double >* obj, int x0);
double CasADi__Matrix_double___elem_TIC(CasADi::Matrix< double >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( obj->elem(x0_) );
}


// ================== Normal method: "hasNZ" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::hasNZ"
// cWrapperName: "CasADi__Matrix_double___hasNZ"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
extern "C"
    int CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1);
int CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( obj->hasNZ(x0_, x1_) );
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__nonzero__"
// cWrapperName: "CasADi__Matrix_double_____nonzero__"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj)"
// call: "obj->__nonzero__()"
extern "C"
    int CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->__nonzero__() );
}


// ================== Normal method: "setSub" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub"
// cWrapperName: "CasADi__Matrix_double___setSub"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, int x2);
void CasADi__Matrix_double___setSub(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, int x2);
void CasADi__Matrix_double___setSub_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::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_);
}


// ================== Normal method: "setSub''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, std::vector< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, int x1, std::vector< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::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_);
}


// ================== Normal method: "setSub'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::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_);
}


// ================== Normal method: "setSub''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, std::vector< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, std::vector< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Slice* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Slice* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Slice* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Slice* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub''''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'''''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub''''''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'''''''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub''''''''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, int x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Slice* x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSub'''''''''''''"
// cWrapperName: "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1, int x2);
void CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setNZ" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setNZ"
// cWrapperName: "CasADi__Matrix_double___setNZ"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setNZ(CasADi::Matrix< double >* obj, int x0, CasADi::Matrix< double >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___setNZ(CasADi::Matrix< double >* obj, int x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___setNZ(CasADi::Matrix< double >* obj, int x0, CasADi::Matrix< double >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setNZ'"
// cWrapperName: "CasADi__Matrix_double___setNZ_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< int >* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setNZ_TIC(CasADi::Matrix< double >* obj, std::vector< int >* x0, CasADi::Matrix< double >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___setNZ_TIC(CasADi::Matrix< double >* obj, std::vector< int >* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___setNZ_TIC(CasADi::Matrix< double >* obj, std::vector< int >* x0, CasADi::Matrix< double >* x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setNZ''"
// cWrapperName: "CasADi__Matrix_double___setNZ_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setNZ_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___setNZ_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___setNZ_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setNZ'''"
// cWrapperName: "CasADi__Matrix_double___setNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setNZ_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___setNZ_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___setNZ_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "append" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::append"
// cWrapperName: "CasADi__Matrix_double___append"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___append(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->append(x0_)"
extern "C"
    void CasADi__Matrix_double___append(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
void CasADi__Matrix_double___append(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    obj->append(x0_);
}


// ================== Normal method: "appendColumns" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::appendColumns"
// cWrapperName: "CasADi__Matrix_double___appendColumns"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___appendColumns(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->appendColumns(x0_)"
extern "C"
    void CasADi__Matrix_double___appendColumns(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
void CasADi__Matrix_double___appendColumns(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    obj->appendColumns(x0_);
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nz_indexed_one_based_assignment"
// cWrapperName: "CasADi__Matrix_double___nz_indexed_one_based_assignment"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___nz_indexed_one_based_assignment(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___nz_indexed_one_based_assignment(CasADi::Matrix< double >* obj, int x0, double const * x1);
void CasADi__Matrix_double___nz_indexed_one_based_assignment(CasADi::Matrix< double >* obj, int x0, double const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nz_indexed_zero_based_assignment"
// cWrapperName: "CasADi__Matrix_double___nz_indexed_zero_based_assignment"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___nz_indexed_zero_based_assignment(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___nz_indexed_zero_based_assignment(CasADi::Matrix< double >* obj, int x0, double const * x1);
void CasADi__Matrix_double___nz_indexed_zero_based_assignment(CasADi::Matrix< double >* obj, int x0, double const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nz_indexed_assignment"
// cWrapperName: "CasADi__Matrix_double___nz_indexed_assignment"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___nz_indexed_assignment(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___nz_indexed_assignment(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___nz_indexed_assignment(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_one_based_assignment"
// cWrapperName: "CasADi__Matrix_double___indexed_one_based_assignment"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_one_based_assignment(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_one_based_assignment(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___indexed_one_based_assignment(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_zero_based_assignment"
// cWrapperName: "CasADi__Matrix_double___indexed_zero_based_assignment"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_zero_based_assignment(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_zero_based_assignment(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___indexed_zero_based_assignment(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_one_based_assignment'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nz_indexed_one_based_assignment'"
// cWrapperName: "CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_zero_based_assignment'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nz_indexed_zero_based_assignment'"
// cWrapperName: "CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nz_indexed_assignment'"
// cWrapperName: "CasADi__Matrix_double___nz_indexed_assignment_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___nz_indexed_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___nz_indexed_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___nz_indexed_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_one_based_assignment'"
// cWrapperName: "CasADi__Matrix_double___indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_one_based_assignment_TIC(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_one_based_assignment_TIC(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2);
void CasADi__Matrix_double___indexed_one_based_assignment_TIC(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    double const & x2_ = Marshaling<double const &,double const *>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_zero_based_assignment'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_zero_based_assignment'"
// cWrapperName: "CasADi__Matrix_double___indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_zero_based_assignment_TIC(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_zero_based_assignment_TIC(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2);
void CasADi__Matrix_double___indexed_zero_based_assignment_TIC(CasADi::Matrix< double >* obj, int x0, int x1, double const * x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    double const & x2_ = Marshaling<double const &,double const *>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment'"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment'''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment''''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment'''''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment''''''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment'''''''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, CasADi::Matrix< double >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, CasADi::Matrix< double >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_one_based_assignment''"
// cWrapperName: "CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< double >* obj, int x0, double const * x1);
void CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< double >* obj, int x0, double const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_zero_based_assignment''"
// cWrapperName: "CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< double >* obj, int x0, double const * x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< double >* obj, int x0, double const * x1);
void CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< double >* obj, int x0, double const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment''''''''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Slice* x0, CasADi::Matrix< double >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment'''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::indexed_assignment'''''''''"
// cWrapperName: "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1);
void CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::IndexList* x0, CasADi::Matrix< double >* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "setZero" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setZero"
// cWrapperName: "CasADi__Matrix_double___setZero"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setZero(CasADi::Matrix< double >* obj)"
// call: "obj->setZero()"
extern "C"
    void CasADi__Matrix_double___setZero(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___setZero(CasADi::Matrix< double >* obj){

    obj->setZero();
}


// ================== Normal method: "setAll" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setAll"
// cWrapperName: "CasADi__Matrix_double___setAll"
// protoArgs: "(CasADi::Matrix< double >* obj, double const * x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setAll(CasADi::Matrix< double >* obj, double const * x0)"
// call: "obj->setAll(x0_)"
extern "C"
    void CasADi__Matrix_double___setAll(CasADi::Matrix< double >* obj, double const * x0);
void CasADi__Matrix_double___setAll(CasADi::Matrix< double >* obj, double const * x0){
    double const & x0_ = Marshaling<double const &,double const *>::marshal(x0);

    obj->setAll(x0_);
}


// ================== Normal method: "setSparse" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSparse"
// cWrapperName: "CasADi__Matrix_double___setSparse"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___setSparse(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___setSparse(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, int x1);
CasADi::Matrix< double >* CasADi__Matrix_double___setSparse(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->setSparse(x0_, x1_) );
}


// ================== Normal method: "setSparse'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setSparse'"
// cWrapperName: "CasADi__Matrix_double___setSparse_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___setSparse_TIC(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___setSparse_TIC(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___setSparse_TIC(CasADi::Matrix< double >* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->setSparse(x0_) );
}


// ================== Normal method: "densify" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::densify"
// cWrapperName: "CasADi__Matrix_double___densify"
// protoArgs: "(CasADi::Matrix< double >* obj, double const * x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___densify(CasADi::Matrix< double >* obj, double const * x0)"
// call: "obj->densify(x0_)"
extern "C"
    void CasADi__Matrix_double___densify(CasADi::Matrix< double >* obj, double const * x0);
void CasADi__Matrix_double___densify(CasADi::Matrix< double >* obj, double const * x0){
    double const & x0_ = Marshaling<double const &,double const *>::marshal(x0);

    obj->densify(x0_);
}


// ================== Normal method: "densify'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::densify'"
// cWrapperName: "CasADi__Matrix_double___densify_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___densify_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->densify()"
extern "C"
    void CasADi__Matrix_double___densify_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___densify_TIC(CasADi::Matrix< double >* obj){

    obj->densify();
}


// ================== Normal method: "sparsify" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sparsify"
// cWrapperName: "CasADi__Matrix_double___sparsify"
// protoArgs: "(CasADi::Matrix< double >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___sparsify(CasADi::Matrix< double >* obj, double x0)"
// call: "obj->sparsify(x0_)"
extern "C"
    void CasADi__Matrix_double___sparsify(CasADi::Matrix< double >* obj, double x0);
void CasADi__Matrix_double___sparsify(CasADi::Matrix< double >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->sparsify(x0_);
}


// ================== Normal method: "sparsify'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sparsify'"
// cWrapperName: "CasADi__Matrix_double___sparsify_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___sparsify_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->sparsify()"
extern "C"
    void CasADi__Matrix_double___sparsify_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___sparsify_TIC(CasADi::Matrix< double >* obj){

    obj->sparsify();
}


// ================== Normal method: "operator +" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::operator +"
// cWrapperName: "CasADi__Matrix_double___operator_plus"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___operator_plus(CasADi::Matrix< double >* obj)"
// call: "obj->operator +()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___operator_plus(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___operator_plus(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->operator +() );
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::operator -"
// cWrapperName: "CasADi__Matrix_double___operator_minus"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___operator_minus(CasADi::Matrix< double >* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___operator_minus(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___operator_minus(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->operator -() );
}


// ================== Static method: "binary" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::binary"
// cWrapperName: "CasADi__Matrix_double___binary"
// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___binary(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___binary(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
CasADi::Matrix< double >* CasADi__Matrix_double___binary(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::binary(x0_, x1_, x2_) );
}


// ================== Static method: "unary" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::unary"
// cWrapperName: "CasADi__Matrix_double___unary"
// protoArgs: "(int x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___unary(int x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::Matrix< double >::unary(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___unary(int x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___unary(int x0, CasADi::Matrix< double >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::unary(x0_, x1_) );
}


// ================== Static method: "scalar_matrix" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::scalar_matrix"
// cWrapperName: "CasADi__Matrix_double___scalar_matrix"
// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___scalar_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::scalar_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___scalar_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
CasADi::Matrix< double >* CasADi__Matrix_double___scalar_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::scalar_matrix(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_scalar" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::matrix_scalar"
// cWrapperName: "CasADi__Matrix_double___matrix_scalar"
// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___matrix_scalar(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::matrix_scalar(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___matrix_scalar(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
CasADi::Matrix< double >* CasADi__Matrix_double___matrix_scalar(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::matrix_scalar(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_matrix" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::matrix_matrix"
// cWrapperName: "CasADi__Matrix_double___matrix_matrix"
// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___matrix_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::matrix_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___matrix_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
CasADi::Matrix< double >* CasADi__Matrix_double___matrix_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::matrix_matrix(x0_, x1_, x2_) );
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__add__"
// cWrapperName: "CasADi__Matrix_double_____add__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____add__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____add__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____add__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__sub__"
// cWrapperName: "CasADi__Matrix_double_____sub__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____sub__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____sub__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____sub__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__mul__"
// cWrapperName: "CasADi__Matrix_double_____mul__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____mul__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____mul__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____mul__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__div__"
// cWrapperName: "CasADi__Matrix_double_____div__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____div__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____div__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____div__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__lt__"
// cWrapperName: "CasADi__Matrix_double_____lt__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____lt__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____lt__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____lt__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__le__"
// cWrapperName: "CasADi__Matrix_double_____le__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____le__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____le__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____le__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__eq__"
// cWrapperName: "CasADi__Matrix_double_____eq__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____eq__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____eq__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____eq__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__ne__"
// cWrapperName: "CasADi__Matrix_double_____ne__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____ne__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____ne__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____ne__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__truediv__"
// cWrapperName: "CasADi__Matrix_double_____truediv__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____truediv__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____truediv__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____truediv__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__pow__"
// cWrapperName: "CasADi__Matrix_double_____pow__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____pow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____pow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____pow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__constpow__"
// cWrapperName: "CasADi__Matrix_double_____constpow__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____constpow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____constpow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____constpow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__mpower__"
// cWrapperName: "CasADi__Matrix_double_____mpower__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____mpower__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____mpower__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____mpower__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__mpower__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__mrdivide__"
// cWrapperName: "CasADi__Matrix_double_____mrdivide__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____mrdivide__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____mrdivide__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____mrdivide__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "mul_full" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_full"
// cWrapperName: "CasADi__Matrix_double___mul_full"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->mul_full(x0_, x1_) );
}


// ================== Normal method: "mul_full'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_full'"
// cWrapperName: "CasADi__Matrix_double___mul_full_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_full_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->mul_full(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___mul_full_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___mul_full_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->mul_full(x0_) );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul"
// cWrapperName: "CasADi__Matrix_double___mul"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->mul(x0_, x1_) );
}


// ================== Normal method: "mul'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul'"
// cWrapperName: "CasADi__Matrix_double___mul_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___mul_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___mul_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->mul(x0_) );
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_no_alloc_nn"
// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_nn"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___mul_no_alloc_nn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___mul_no_alloc_nn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___mul_no_alloc_nn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double >& x2_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x2);

    CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_no_alloc_tn"
// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_tn"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___mul_no_alloc_tn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___mul_no_alloc_tn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___mul_no_alloc_tn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double >& x2_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x2);

    CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_nt" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_no_alloc_nt"
// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_nt"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___mul_no_alloc_nt(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Matrix< double >::mul_no_alloc_nt(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___mul_no_alloc_nt(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
void CasADi__Matrix_double___mul_no_alloc_nt(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double >& x2_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x2);

    CasADi::Matrix< double >::mul_no_alloc_nt(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_tn'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_no_alloc_tn'"
// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_tn_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2)"
// call: "CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2);
void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::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::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_nn'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::mul_no_alloc_nn'"
// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_nn_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2)"
// call: "CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2);
void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::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::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_);
}


// ================== Static method: "quad_form" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::quad_form"
// cWrapperName: "CasADi__Matrix_double___quad_form"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector< double >* x1)"
// call: "CasADi::Matrix< double >::quad_form(x0_, x1_)"
extern "C"
    double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector< double >* x1);
double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    return WrapReturn< double, double >::wrapReturn( CasADi::Matrix< double >::quad_form(x0_, x1_) );
}


// ================== Normal method: "trans" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::trans"
// cWrapperName: "CasADi__Matrix_double___trans"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___trans(CasADi::Matrix< double >* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___trans(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___trans(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->trans() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sin"
// cWrapperName: "CasADi__Matrix_double___sin"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sin(CasADi::Matrix< double >* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sin(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___sin(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::cos"
// cWrapperName: "CasADi__Matrix_double___cos"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___cos(CasADi::Matrix< double >* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___cos(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___cos(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::tan"
// cWrapperName: "CasADi__Matrix_double___tan"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___tan(CasADi::Matrix< double >* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___tan(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___tan(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arcsin"
// cWrapperName: "CasADi__Matrix_double___arcsin"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arcsin(CasADi::Matrix< double >* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arcsin(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___arcsin(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arccos"
// cWrapperName: "CasADi__Matrix_double___arccos"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arccos(CasADi::Matrix< double >* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arccos(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___arccos(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arctan"
// cWrapperName: "CasADi__Matrix_double___arctan"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arctan(CasADi::Matrix< double >* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arctan(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___arctan(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arctan() );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::exp"
// cWrapperName: "CasADi__Matrix_double___exp"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___exp(CasADi::Matrix< double >* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___exp(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___exp(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::log"
// cWrapperName: "CasADi__Matrix_double___log"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___log(CasADi::Matrix< double >* obj)"
// call: "obj->log()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___log(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___log(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->log() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sqrt"
// cWrapperName: "CasADi__Matrix_double___sqrt"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sqrt(CasADi::Matrix< double >* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sqrt(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___sqrt(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->sqrt() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::floor"
// cWrapperName: "CasADi__Matrix_double___floor"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___floor(CasADi::Matrix< double >* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___floor(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___floor(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::ceil"
// cWrapperName: "CasADi__Matrix_double___ceil"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ceil(CasADi::Matrix< double >* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___ceil(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___ceil(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->ceil() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::fabs"
// cWrapperName: "CasADi__Matrix_double___fabs"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___fabs(CasADi::Matrix< double >* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___fabs(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___fabs(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->fabs() );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sign"
// cWrapperName: "CasADi__Matrix_double___sign"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sign(CasADi::Matrix< double >* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sign(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___sign(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->sign() );
}


// ================== Normal method: "__copysign__" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::__copysign__"
// cWrapperName: "CasADi__Matrix_double_____copysign__"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____copysign__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->__copysign__(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double_____copysign__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double_____copysign__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->__copysign__(x0_) );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::erfinv"
// cWrapperName: "CasADi__Matrix_double___erfinv"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___erfinv(CasADi::Matrix< double >* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___erfinv(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___erfinv(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->erfinv() );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::fmin"
// cWrapperName: "CasADi__Matrix_double___fmin"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___fmin(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___fmin(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___fmin(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::fmax"
// cWrapperName: "CasADi__Matrix_double___fmax"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___fmax(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___fmax(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___fmax(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->fmax(x0_) );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::erf"
// cWrapperName: "CasADi__Matrix_double___erf"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___erf(CasADi::Matrix< double >* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___erf(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___erf(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->erf() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sinh"
// cWrapperName: "CasADi__Matrix_double___sinh"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sinh(CasADi::Matrix< double >* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sinh(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___sinh(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::cosh"
// cWrapperName: "CasADi__Matrix_double___cosh"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___cosh(CasADi::Matrix< double >* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___cosh(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___cosh(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::tanh"
// cWrapperName: "CasADi__Matrix_double___tanh"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___tanh(CasADi::Matrix< double >* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___tanh(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___tanh(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arcsinh"
// cWrapperName: "CasADi__Matrix_double___arcsinh"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arcsinh(CasADi::Matrix< double >* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arcsinh(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___arcsinh(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arccosh"
// cWrapperName: "CasADi__Matrix_double___arccosh"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arccosh(CasADi::Matrix< double >* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arccosh(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___arccosh(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arctanh"
// cWrapperName: "CasADi__Matrix_double___arctanh"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arctanh(CasADi::Matrix< double >* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arctanh(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___arctanh(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arctanh() );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::arctan2"
// cWrapperName: "CasADi__Matrix_double___arctan2"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arctan2(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___arctan2(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___arctan2(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->arctan2(x0_) );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::log10"
// cWrapperName: "CasADi__Matrix_double___log10"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___log10(CasADi::Matrix< double >* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___log10(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___log10(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->log10() );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::printme"
// cWrapperName: "CasADi__Matrix_double___printme"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___printme(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___printme(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___printme(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->printme(x0_) );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::logic_not"
// cWrapperName: "CasADi__Matrix_double___logic_not"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___logic_not(CasADi::Matrix< double >* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___logic_not(CasADi::Matrix< double >* obj);
CasADi::Matrix< double >* CasADi__Matrix_double___logic_not(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->logic_not() );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::logic_and"
// cWrapperName: "CasADi__Matrix_double___logic_and"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___logic_and(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___logic_and(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___logic_and(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::logic_or"
// cWrapperName: "CasADi__Matrix_double___logic_or"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___logic_or(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___logic_or(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___logic_or(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::if_else_zero"
// cWrapperName: "CasADi__Matrix_double___if_else_zero"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___if_else_zero(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___if_else_zero(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___if_else_zero(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->if_else_zero(x0_) );
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setMaxNumCallsInPrint"
// cWrapperName: "CasADi__Matrix_double___setMaxNumCallsInPrint"
// protoArgs: "(long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setMaxNumCallsInPrint(long x0)"
// call: "CasADi::Matrix< double >::setMaxNumCallsInPrint(x0_)"
extern "C"
    void CasADi__Matrix_double___setMaxNumCallsInPrint(long x0);
void CasADi__Matrix_double___setMaxNumCallsInPrint(long x0){
    long x0_ = Marshaling<long,long>::marshal(x0);

    CasADi::Matrix< double >::setMaxNumCallsInPrint(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setMaxNumCallsInPrint'"
// cWrapperName: "CasADi__Matrix_double___setMaxNumCallsInPrint_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setMaxNumCallsInPrint_TIC()"
// call: "CasADi::Matrix< double >::setMaxNumCallsInPrint()"
extern "C"
    void CasADi__Matrix_double___setMaxNumCallsInPrint_TIC();
void CasADi__Matrix_double___setMaxNumCallsInPrint_TIC(){

    CasADi::Matrix< double >::setMaxNumCallsInPrint();
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::getMaxNumCallsInPrint"
// cWrapperName: "CasADi__Matrix_double___getMaxNumCallsInPrint"
// protoArgs: "()"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long CasADi__Matrix_double___getMaxNumCallsInPrint()"
// call: "CasADi::Matrix< double >::getMaxNumCallsInPrint()"
extern "C"
    long CasADi__Matrix_double___getMaxNumCallsInPrint();
long CasADi__Matrix_double___getMaxNumCallsInPrint(){

    return WrapReturn< long, long >::wrapReturn( CasADi::Matrix< double >::getMaxNumCallsInPrint() );
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setEqualityCheckingDepth"
// cWrapperName: "CasADi__Matrix_double___setEqualityCheckingDepth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setEqualityCheckingDepth(int x0)"
// call: "CasADi::Matrix< double >::setEqualityCheckingDepth(x0_)"
extern "C"
    void CasADi__Matrix_double___setEqualityCheckingDepth(int x0);
void CasADi__Matrix_double___setEqualityCheckingDepth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< double >::setEqualityCheckingDepth(x0_);
}


// ================== Static method: "setEqualityCheckingDepth'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setEqualityCheckingDepth'"
// cWrapperName: "CasADi__Matrix_double___setEqualityCheckingDepth_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setEqualityCheckingDepth_TIC()"
// call: "CasADi::Matrix< double >::setEqualityCheckingDepth()"
extern "C"
    void CasADi__Matrix_double___setEqualityCheckingDepth_TIC();
void CasADi__Matrix_double___setEqualityCheckingDepth_TIC(){

    CasADi::Matrix< double >::setEqualityCheckingDepth();
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::getEqualityCheckingDepth"
// cWrapperName: "CasADi__Matrix_double___getEqualityCheckingDepth"
// protoArgs: "()"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___getEqualityCheckingDepth()"
// call: "CasADi::Matrix< double >::getEqualityCheckingDepth()"
extern "C"
    int CasADi__Matrix_double___getEqualityCheckingDepth();
int CasADi__Matrix_double___getEqualityCheckingDepth(){

    return WrapReturn< int, int >::wrapReturn( CasADi::Matrix< double >::getEqualityCheckingDepth() );
}


// ================== Static method: "className" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::className"
// cWrapperName: "CasADi__Matrix_double___className"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Matrix_double___className()"
// call: "CasADi::Matrix< double >::className()"
extern "C"
    std::string* CasADi__Matrix_double___className();
std::string* CasADi__Matrix_double___className(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::Matrix< double >::className() );
}


// ================== Normal method: "printScalar'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::printScalar'"
// cWrapperName: "CasADi__Matrix_double___printScalar_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___printScalar_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->printScalar()"
extern "C"
    void CasADi__Matrix_double___printScalar_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___printScalar_TIC(CasADi::Matrix< double >* obj){

    obj->printScalar();
}


// ================== Normal method: "printVector'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::printVector'"
// cWrapperName: "CasADi__Matrix_double___printVector_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___printVector_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->printVector()"
extern "C"
    void CasADi__Matrix_double___printVector_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___printVector_TIC(CasADi::Matrix< double >* obj){

    obj->printVector();
}


// ================== Normal method: "printDense'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::printDense'"
// cWrapperName: "CasADi__Matrix_double___printDense_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___printDense_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->printDense()"
extern "C"
    void CasADi__Matrix_double___printDense_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___printDense_TIC(CasADi::Matrix< double >* obj){

    obj->printDense();
}


// ================== Normal method: "printSparse'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::printSparse'"
// cWrapperName: "CasADi__Matrix_double___printSparse_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___printSparse_TIC(CasADi::Matrix< double >* obj)"
// call: "obj->printSparse()"
extern "C"
    void CasADi__Matrix_double___printSparse_TIC(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___printSparse_TIC(CasADi::Matrix< double >* obj){

    obj->printSparse();
}


// ================== Normal method: "row" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::row"
// cWrapperName: "CasADi__Matrix_double___row"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___row(CasADi::Matrix< double >* obj, int x0)"
// call: "obj->row(x0_)"
extern "C"
    int CasADi__Matrix_double___row(CasADi::Matrix< double >* obj, int x0);
int CasADi__Matrix_double___row(CasADi::Matrix< double >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->row(x0_) );
}


// ================== Normal method: "colind" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::colind"
// cWrapperName: "CasADi__Matrix_double___colind"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___colind(CasADi::Matrix< double >* obj, int x0)"
// call: "obj->colind(x0_)"
extern "C"
    int CasADi__Matrix_double___colind(CasADi::Matrix< double >* obj, int x0);
int CasADi__Matrix_double___colind(CasADi::Matrix< double >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->colind(x0_) );
}


// ================== Normal method: "clear" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::clear"
// cWrapperName: "CasADi__Matrix_double___clear"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___clear(CasADi::Matrix< double >* obj)"
// call: "obj->clear()"
extern "C"
    void CasADi__Matrix_double___clear(CasADi::Matrix< double >* obj);
void CasADi__Matrix_double___clear(CasADi::Matrix< double >* obj){

    obj->clear();
}


// ================== Normal method: "resize" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::resize"
// cWrapperName: "CasADi__Matrix_double___resize"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___resize(CasADi::Matrix< double >* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___resize(CasADi::Matrix< double >* obj, int x0, int x1);
void CasADi__Matrix_double___resize(CasADi::Matrix< double >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
}


// ================== Normal method: "reserve" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::reserve"
// cWrapperName: "CasADi__Matrix_double___reserve"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___reserve(CasADi::Matrix< double >* obj, int x0)"
// call: "obj->reserve(x0_)"
extern "C"
    void CasADi__Matrix_double___reserve(CasADi::Matrix< double >* obj, int x0);
void CasADi__Matrix_double___reserve(CasADi::Matrix< double >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->reserve(x0_);
}


// ================== Normal method: "reserve'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::reserve'"
// cWrapperName: "CasADi__Matrix_double___reserve_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___reserve_TIC(CasADi::Matrix< double >* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___reserve_TIC(CasADi::Matrix< double >* obj, int x0, int x1);
void CasADi__Matrix_double___reserve_TIC(CasADi::Matrix< double >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
}


// ================== Normal method: "erase" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::erase"
// cWrapperName: "CasADi__Matrix_double___erase"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "remove" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::remove"
// cWrapperName: "CasADi__Matrix_double___remove"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->remove(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "enlarge" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::enlarge"
// cWrapperName: "CasADi__Matrix_double___enlarge"
// protoArgs: "(CasADi::Matrix< double >* 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__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void CasADi__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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_);
}


// ================== Normal method: "data" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::data"
// cWrapperName: "CasADi__Matrix_double___data"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj)"
// call: "obj->data()"
extern "C"
    std::vector< double >* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj);
std::vector< double >* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj){

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->data() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sparsityRef"
// cWrapperName: "CasADi__Matrix_double___sparsityRef"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj);
CasADi::Sparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Normal method: "set" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::set"
// cWrapperName: "CasADi__Matrix_double___set"
// protoArgs: "(CasADi::Matrix< double >* obj, double x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::SparsityType x1);
void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::SparsityType x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::set'"
// cWrapperName: "CasADi__Matrix_double___set_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC(CasADi::Matrix< double >* obj, double x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_double___set_TIC(CasADi::Matrix< double >* obj, double x0);
void CasADi__Matrix_double___set_TIC(CasADi::Matrix< double >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::get"
// cWrapperName: "CasADi__Matrix_double___get"
// protoArgs: "(CasADi::Matrix< double >* obj, double* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::SparsityType x1);
void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::SparsityType x1){
    double& x0_ = Marshaling<double&,double*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::get'"
// cWrapperName: "CasADi__Matrix_double___get_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, double* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC(CasADi::Matrix< double >* obj, double* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_double___get_TIC(CasADi::Matrix< double >* obj, double* x0);
void CasADi__Matrix_double___get_TIC(CasADi::Matrix< double >* obj, double* x0){
    double& x0_ = Marshaling<double&,double*>::marshal(x0);

    obj->get(x0_);
}


// ================== Normal method: "set''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::set''"
// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::set'''"
// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0);
void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::get''"
// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0, CasADi::SparsityType x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::get'''"
// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0);
void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->get(x0_);
}


// ================== Normal method: "set''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::set''''"
// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::set'''''"
// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::get''''"
// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::SparsityType x1){
    CasADi::Matrix< double >& x0_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::get'''''"
// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double >& x0_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x0);

    obj->get(x0_);
}


// ================== Static method: "triplet" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::triplet"
// cWrapperName: "CasADi__Matrix_double___triplet"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2)"
// call: "CasADi::Matrix< double >::triplet(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2);
CasADi::Matrix< double >* CasADi__Matrix_double___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2){
    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);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::triplet(x0_, x1_, x2_) );
}


// ================== Static method: "triplet'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::triplet'"
// cWrapperName: "CasADi__Matrix_double___triplet_TIC"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4)"
// call: "CasADi::Matrix< double >::triplet(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4);
CasADi::Matrix< double >* CasADi__Matrix_double___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< double >* x2, int x3, int x4){
    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);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::triplet(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::inf"
// cWrapperName: "CasADi__Matrix_double___inf"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< double >::inf(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::Sparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::inf(x0_) );
}


// ================== Static method: "inf'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::inf'"
// cWrapperName: "CasADi__Matrix_double___inf_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC(int x0, int x1)"
// call: "CasADi::Matrix< double >::inf(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC(int x0, int x1);
CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::inf(x0_, x1_) );
}


// ================== Static method: "inf''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::inf''"
// cWrapperName: "CasADi__Matrix_double___inf_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC(int x0)"
// call: "CasADi::Matrix< double >::inf(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC(int x0);
CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::inf(x0_) );
}


// ================== Static method: "inf'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::inf'''"
// cWrapperName: "CasADi__Matrix_double___inf_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC_TIC()"
// call: "CasADi::Matrix< double >::inf()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC_TIC();
CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nan"
// cWrapperName: "CasADi__Matrix_double___nan"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< double >::nan(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::Sparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::nan(x0_) );
}


// ================== Static method: "nan'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nan'"
// cWrapperName: "CasADi__Matrix_double___nan_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC(int x0, int x1)"
// call: "CasADi::Matrix< double >::nan(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC(int x0, int x1);
CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::nan(x0_, x1_) );
}


// ================== Static method: "nan''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nan''"
// cWrapperName: "CasADi__Matrix_double___nan_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC(int x0)"
// call: "CasADi::Matrix< double >::nan(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC(int x0);
CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::nan(x0_) );
}


// ================== Static method: "nan'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nan'''"
// cWrapperName: "CasADi__Matrix_double___nan_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC_TIC()"
// call: "CasADi::Matrix< double >::nan()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC_TIC();
CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::repmat"
// cWrapperName: "CasADi__Matrix_double___repmat"
// protoArgs: "(double const * x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat(double const * x0, CasADi::Sparsity* x1)"
// call: "CasADi::Matrix< double >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___repmat(double const * x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___repmat(double const * x0, CasADi::Sparsity* x1){
    double const & x0_ = Marshaling<double const &,double const *>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::repmat(x0_, x1_) );
}


// ================== Static method: "repmat'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::repmat'"
// cWrapperName: "CasADi__Matrix_double___repmat_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::Matrix< double >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::repmat(x0_, x1_) );
}


// ================== Static method: "repmat''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::repmat''"
// cWrapperName: "CasADi__Matrix_double___repmat_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "CasADi::Matrix< double >::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::repmat(x0_, x1_, x2_) );
}


// ================== Static method: "repmat'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::repmat'''"
// cWrapperName: "CasADi__Matrix_double___repmat_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"
// call: "CasADi::Matrix< double >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);
CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::repmat(x0_, x1_) );
}


// ================== Static method: "eye" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::eye"
// cWrapperName: "CasADi__Matrix_double___eye"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___eye(int x0)"
// call: "CasADi::Matrix< double >::eye(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___eye(int x0);
CasADi::Matrix< double >* CasADi__Matrix_double___eye(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >::eye(x0_) );
}


// ================== Normal method: "isRegular" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isRegular"
// cWrapperName: "CasADi__Matrix_double___isRegular"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isRegular(CasADi::Matrix< double >* obj)"
// call: "obj->isRegular()"
extern "C"
    int CasADi__Matrix_double___isRegular(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isRegular(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isRegular() );
}


// ================== Normal method: "isSmooth" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isSmooth"
// cWrapperName: "CasADi__Matrix_double___isSmooth"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isSmooth(CasADi::Matrix< double >* obj)"
// call: "obj->isSmooth()"
extern "C"
    int CasADi__Matrix_double___isSmooth(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isSmooth(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSmooth() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isSymbolic"
// cWrapperName: "CasADi__Matrix_double___isSymbolic"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isSymbolic(CasADi::Matrix< double >* obj)"
// call: "obj->isSymbolic()"
extern "C"
    int CasADi__Matrix_double___isSymbolic(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isSymbolic(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolic() );
}


// ================== Normal method: "isSymbolicSparse" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isSymbolicSparse"
// cWrapperName: "CasADi__Matrix_double___isSymbolicSparse"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isSymbolicSparse(CasADi::Matrix< double >* obj)"
// call: "obj->isSymbolicSparse()"
extern "C"
    int CasADi__Matrix_double___isSymbolicSparse(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isSymbolicSparse(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolicSparse() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isConstant"
// cWrapperName: "CasADi__Matrix_double___isConstant"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isConstant(CasADi::Matrix< double >* obj)"
// call: "obj->isConstant()"
extern "C"
    int CasADi__Matrix_double___isConstant(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isConstant(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isConstant() );
}


// ================== Normal method: "isInteger" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isInteger"
// cWrapperName: "CasADi__Matrix_double___isInteger"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isInteger(CasADi::Matrix< double >* obj)"
// call: "obj->isInteger()"
extern "C"
    int CasADi__Matrix_double___isInteger(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isInteger(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInteger() );
}


// ================== Normal method: "isZero" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isZero"
// cWrapperName: "CasADi__Matrix_double___isZero"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isZero(CasADi::Matrix< double >* obj)"
// call: "obj->isZero()"
extern "C"
    int CasADi__Matrix_double___isZero(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isZero(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isZero() );
}


// ================== Normal method: "isOne" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isOne"
// cWrapperName: "CasADi__Matrix_double___isOne"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isOne(CasADi::Matrix< double >* obj)"
// call: "obj->isOne()"
extern "C"
    int CasADi__Matrix_double___isOne(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isOne(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isOne() );
}


// ================== Normal method: "isMinusOne" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isMinusOne"
// cWrapperName: "CasADi__Matrix_double___isMinusOne"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isMinusOne(CasADi::Matrix< double >* obj)"
// call: "obj->isMinusOne()"
extern "C"
    int CasADi__Matrix_double___isMinusOne(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isMinusOne(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMinusOne() );
}


// ================== Normal method: "isIdentity" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isIdentity"
// cWrapperName: "CasADi__Matrix_double___isIdentity"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isIdentity(CasADi::Matrix< double >* obj)"
// call: "obj->isIdentity()"
extern "C"
    int CasADi__Matrix_double___isIdentity(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___isIdentity(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isIdentity() );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isEqual"
// cWrapperName: "CasADi__Matrix_double___isEqual"
// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___isEqual(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    int CasADi__Matrix_double___isEqual(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);
int CasADi__Matrix_double___isEqual(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_) );
}


// ================== Normal method: "hasNonStructuralZeros" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::hasNonStructuralZeros"
// cWrapperName: "CasADi__Matrix_double___hasNonStructuralZeros"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_double___hasNonStructuralZeros(CasADi::Matrix< double >* obj)"
// call: "obj->hasNonStructuralZeros()"
extern "C"
    int CasADi__Matrix_double___hasNonStructuralZeros(CasADi::Matrix< double >* obj);
int CasADi__Matrix_double___hasNonStructuralZeros(CasADi::Matrix< double >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->hasNonStructuralZeros() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::getValue"
// cWrapperName: "CasADi__Matrix_double___getValue"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_double___getValue(CasADi::Matrix< double >* obj)"
// call: "obj->getValue()"
extern "C"
    double CasADi__Matrix_double___getValue(CasADi::Matrix< double >* obj);
double CasADi__Matrix_double___getValue(CasADi::Matrix< double >* obj){

    return WrapReturn< double, double >::wrapReturn( obj->getValue() );
}


// ================== Normal method: "getName" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::getName"
// cWrapperName: "CasADi__Matrix_double___getName"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Matrix_double___getName(CasADi::Matrix< double >* obj)"
// call: "obj->getName()"
extern "C"
    std::string* CasADi__Matrix_double___getName(CasADi::Matrix< double >* obj);
std::string* CasADi__Matrix_double___getName(CasADi::Matrix< double >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getName() );
}


// ================== Static method: "setPrecision" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setPrecision"
// cWrapperName: "CasADi__Matrix_double___setPrecision"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setPrecision(int x0)"
// call: "CasADi::Matrix< double >::setPrecision(x0_)"
extern "C"
    void CasADi__Matrix_double___setPrecision(int x0);
void CasADi__Matrix_double___setPrecision(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< double >::setPrecision(x0_);
}


// ================== Static method: "setWidth" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setWidth"
// cWrapperName: "CasADi__Matrix_double___setWidth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setWidth(int x0)"
// call: "CasADi::Matrix< double >::setWidth(x0_)"
extern "C"
    void CasADi__Matrix_double___setWidth(int x0);
void CasADi__Matrix_double___setWidth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< double >::setWidth(x0_);
}


// ================== Static method: "setScientific" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setScientific"
// cWrapperName: "CasADi__Matrix_double___setScientific"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setScientific(int x0)"
// call: "CasADi::Matrix< double >::setScientific(x0_)"
extern "C"
    void CasADi__Matrix_double___setScientific(int x0);
void CasADi__Matrix_double___setScientific(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::Matrix< double >::setScientific(x0_);
}


// ================== Constructor method: "DMatrix" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix()"
// call: "CasADi::Matrix< double >()"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix();
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix(){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >() );
}


// ================== Constructor method: "DMatrix'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC"
// protoArgs: "(std::vector< std::vector< double >* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(std::vector< std::vector< double >* >* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(std::vector< std::vector< double >* >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(std::vector< std::vector< double >* >* x0){
    std::vector< std::vector< double > > x0_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, double const * x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(CasADi::Sparsity* x0, double const * x1)"
// call: "CasADi::Matrix< double >(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(CasADi::Sparsity* x0, double const * x1);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(CasADi::Sparsity* x0, double const * x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_, x1_) );
}


// ================== Constructor method: "DMatrix''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix'''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< double >* x1)"
// call: "CasADi::Matrix< double >(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< double >* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< double >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_, x1_) );
}


// ================== Constructor method: "DMatrix''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(double x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(double x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix'''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0, int x1, int x2)"
// call: "CasADi::Matrix< double >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_, x1_, x2_) );
}


// ================== Constructor method: "DMatrix'''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix''''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix'''''''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2)"
// call: "CasADi::Matrix< double >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::Matrix< double >(x0_, x1_, x2_) );
}



// ================== delete CasadiClass Sparsity===============
// classType: CasadiClass Sparsity
extern "C"
    void delete_CasADi__Sparsity(CasADi::Sparsity* obj);
void delete_CasADi__Sparsity(CasADi::Sparsity* obj){
    delete obj;
}

// ================== Static method: "scalar" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::scalar"
// cWrapperName: "CasADi__Sparsity__scalar"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__scalar(int x0)"
// call: "CasADi::Sparsity::scalar(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__scalar(int x0);
CasADi::Sparsity* CasADi__Sparsity__scalar(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::scalar(x0_) );
}


// ================== Static method: "scalar'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::scalar'"
// cWrapperName: "CasADi__Sparsity__scalar_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__scalar_TIC()"
// call: "CasADi::Sparsity::scalar()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__scalar_TIC();
CasADi::Sparsity* CasADi__Sparsity__scalar_TIC(){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::scalar() );
}


// ================== Static method: "dense" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::dense"
// cWrapperName: "CasADi__Sparsity__dense"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__dense(int x0, int x1)"
// call: "CasADi::Sparsity::dense(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__dense(int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__dense(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::dense(x0_, x1_) );
}


// ================== Static method: "dense'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::dense'"
// cWrapperName: "CasADi__Sparsity__dense_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__dense_TIC(int x0)"
// call: "CasADi::Sparsity::dense(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__dense_TIC(int x0);
CasADi::Sparsity* CasADi__Sparsity__dense_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::dense(x0_) );
}


// ================== Static method: "sparse" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sparse"
// cWrapperName: "CasADi__Sparsity__sparse"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__sparse(int x0, int x1)"
// call: "CasADi::Sparsity::sparse(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__sparse(int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sparse'"
// cWrapperName: "CasADi__Sparsity__sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__sparse_TIC(int x0)"
// call: "CasADi::Sparsity::sparse(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__sparse_TIC(int x0);
CasADi::Sparsity* CasADi__Sparsity__sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::sparse(x0_) );
}


// ================== Static method: "unit" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::unit"
// cWrapperName: "CasADi__Sparsity__unit"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__unit(int x0, int x1)"
// call: "CasADi::Sparsity::unit(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__unit(int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__unit(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::unit(x0_, x1_) );
}


// ================== Static method: "triu" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::triu"
// cWrapperName: "CasADi__Sparsity__triu"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__triu(int x0)"
// call: "CasADi::Sparsity::triu(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__triu(int x0);
CasADi::Sparsity* CasADi__Sparsity__triu(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::triu(x0_) );
}


// ================== Static method: "tril" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::tril"
// cWrapperName: "CasADi__Sparsity__tril"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__tril(int x0)"
// call: "CasADi::Sparsity::tril(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__tril(int x0);
CasADi::Sparsity* CasADi__Sparsity__tril(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::tril(x0_) );
}


// ================== Static method: "diag" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::diag"
// cWrapperName: "CasADi__Sparsity__diag"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__diag(int x0)"
// call: "CasADi::Sparsity::diag(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__diag(int x0);
CasADi::Sparsity* CasADi__Sparsity__diag(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::diag(x0_) );
}


// ================== Static method: "diag'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::diag'"
// cWrapperName: "CasADi__Sparsity__diag_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__diag_TIC(int x0, int x1)"
// call: "CasADi::Sparsity::diag(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__diag_TIC(int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__diag_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::diag(x0_, x1_) );
}


// ================== Static method: "band" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::band"
// cWrapperName: "CasADi__Sparsity__band"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__band(int x0, int x1)"
// call: "CasADi::Sparsity::band(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__band(int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__band(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::band(x0_, x1_) );
}


// ================== Static method: "banded" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::banded"
// cWrapperName: "CasADi__Sparsity__banded"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__banded(int x0, int x1)"
// call: "CasADi::Sparsity::banded(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__banded(int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__banded(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::banded(x0_, x1_) );
}


// ================== Static method: "rowcol" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::rowcol"
// cWrapperName: "CasADi__Sparsity__rowcol"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__rowcol(std::vector< int >* x0, std::vector< int >* x1, int x2, int x3)"
// call: "CasADi::Sparsity::rowcol(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__rowcol(std::vector< int >* x0, std::vector< int >* x1, int x2, int x3);
CasADi::Sparsity* CasADi__Sparsity__rowcol(std::vector< int >* x0, std::vector< int >* x1, int x2, int x3){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::rowcol(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "triplet" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::triplet"
// cWrapperName: "CasADi__Sparsity__triplet"
// protoArgs: "(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: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__triplet(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_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__triplet(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5);
CasADi::Sparsity* CasADi__Sparsity__triplet(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, int x5){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_, x5_) );
}


// ================== Static method: "triplet'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::triplet'"
// cWrapperName: "CasADi__Sparsity__triplet_TIC"
// protoArgs: "(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__triplet_TIC(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_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__triplet_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4);
CasADi::Sparsity* CasADi__Sparsity__triplet_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::triplet(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "triplet''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::triplet''"
// cWrapperName: "CasADi__Sparsity__triplet_TIC_TIC"
// protoArgs: "(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__triplet_TIC_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "CasADi::Sparsity::triplet(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__triplet_TIC_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
CasADi::Sparsity* CasADi__Sparsity__triplet_TIC_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::triplet(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "compressed" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::compressed"
// cWrapperName: "CasADi__Sparsity__compressed"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__compressed(std::vector< int >* x0)"
// call: "CasADi::Sparsity::compressed(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__compressed(std::vector< int >* x0);
CasADi::Sparsity* CasADi__Sparsity__compressed(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity::compressed(x0_) );
}


// ================== Normal method: "reCache" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::reCache"
// cWrapperName: "CasADi__Sparsity__reCache"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__reCache(CasADi::Sparsity* obj)"
// call: "obj->reCache()"
extern "C"
    void CasADi__Sparsity__reCache(CasADi::Sparsity* obj);
void CasADi__Sparsity__reCache(CasADi::Sparsity* obj){

    obj->reCache();
}


// ================== Static method: "clearCache" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::clearCache"
// cWrapperName: "CasADi__Sparsity__clearCache"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__clearCache()"
// call: "CasADi::Sparsity::clearCache()"
extern "C"
    void CasADi__Sparsity__clearCache();
void CasADi__Sparsity__clearCache(){

    CasADi::Sparsity::clearCache();
}


// ================== Normal method: "sanityCheck" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sanityCheck"
// cWrapperName: "CasADi__Sparsity__sanityCheck"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__sanityCheck(CasADi::Sparsity* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
extern "C"
    void CasADi__Sparsity__sanityCheck(CasADi::Sparsity* obj, int x0);
void CasADi__Sparsity__sanityCheck(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
}


// ================== Normal method: "sanityCheck'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sanityCheck'"
// cWrapperName: "CasADi__Sparsity__sanityCheck_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__sanityCheck_TIC(CasADi::Sparsity* obj)"
// call: "obj->sanityCheck()"
extern "C"
    void CasADi__Sparsity__sanityCheck_TIC(CasADi::Sparsity* obj);
void CasADi__Sparsity__sanityCheck_TIC(CasADi::Sparsity* obj){

    obj->sanityCheck();
}


// ================== Normal method: "getDiag" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getDiag"
// cWrapperName: "CasADi__Sparsity__getDiag"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__getDiag(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->getDiag(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__getDiag(CasADi::Sparsity* obj, std::vector< int >* x0);
CasADi::Sparsity* CasADi__Sparsity__getDiag(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getDiag(x0_) );
}


// ================== Normal method: "compress" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::compress"
// cWrapperName: "CasADi__Sparsity__compress"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__compress(CasADi::Sparsity* obj)"
// call: "obj->compress()"
extern "C"
    std::vector< int >* CasADi__Sparsity__compress(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__compress(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->compress() );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::checkNode"
// cWrapperName: "CasADi__Sparsity__checkNode"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__checkNode(CasADi::Sparsity* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__Sparsity__checkNode(CasADi::Sparsity* obj);
int CasADi__Sparsity__checkNode(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isEqual"
// cWrapperName: "CasADi__Sparsity__isEqual"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isEqual(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    int CasADi__Sparsity__isEqual(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
int CasADi__Sparsity__isEqual(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_) );
}


// ================== Normal method: "isEqual'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isEqual'"
// cWrapperName: "CasADi__Sparsity__isEqual_TIC"
// protoArgs: "(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_TIC(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->isEqual(x0_, x1_, x2_, x3_)"
extern "C"
    int CasADi__Sparsity__isEqual_TIC(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
int CasADi__Sparsity__isEqual_TIC(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "operator ==" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::operator =="
// cWrapperName: "CasADi__Sparsity__operator_equals"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__operator_equals(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->operator ==(x0_)"
extern "C"
    int CasADi__Sparsity__operator_equals(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
int CasADi__Sparsity__operator_equals(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->operator ==(x0_) );
}


// ================== Normal method: "operator !=" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::operator !="
// cWrapperName: "CasADi__Sparsity__operator_nequals"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__operator_nequals(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->operator !=(x0_)"
extern "C"
    int CasADi__Sparsity__operator_nequals(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
int CasADi__Sparsity__operator_nequals(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->operator !=(x0_) );
}


// ================== Normal method: "size1" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::size1"
// cWrapperName: "CasADi__Sparsity__size1"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__size1(CasADi::Sparsity* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__Sparsity__size1(CasADi::Sparsity* obj);
int CasADi__Sparsity__size1(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size1() );
}


// ================== Normal method: "size2" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::size2"
// cWrapperName: "CasADi__Sparsity__size2"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__size2(CasADi::Sparsity* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__Sparsity__size2(CasADi::Sparsity* obj);
int CasADi__Sparsity__size2(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size2() );
}


// ================== Normal method: "numel" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::numel"
// cWrapperName: "CasADi__Sparsity__numel"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__numel(CasADi::Sparsity* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__Sparsity__numel(CasADi::Sparsity* obj);
int CasADi__Sparsity__numel(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->numel() );
}


// ================== Normal method: "isEmpty" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isEmpty"
// cWrapperName: "CasADi__Sparsity__isEmpty"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isEmpty(CasADi::Sparsity* obj, int x0)"
// call: "obj->isEmpty(x0_)"
extern "C"
    int CasADi__Sparsity__isEmpty(CasADi::Sparsity* obj, int x0);
int CasADi__Sparsity__isEmpty(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty(x0_) );
}


// ================== Normal method: "isEmpty'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isEmpty'"
// cWrapperName: "CasADi__Sparsity__isEmpty_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isEmpty_TIC(CasADi::Sparsity* obj)"
// call: "obj->isEmpty()"
extern "C"
    int CasADi__Sparsity__isEmpty_TIC(CasADi::Sparsity* obj);
int CasADi__Sparsity__isEmpty_TIC(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty() );
}


// ================== Normal method: "size" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::size"
// cWrapperName: "CasADi__Sparsity__size"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__size(CasADi::Sparsity* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__Sparsity__size(CasADi::Sparsity* obj);
int CasADi__Sparsity__size(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size() );
}


// ================== Normal method: "sizeU" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sizeU"
// cWrapperName: "CasADi__Sparsity__sizeU"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__sizeU(CasADi::Sparsity* obj)"
// call: "obj->sizeU()"
extern "C"
    int CasADi__Sparsity__sizeU(CasADi::Sparsity* obj);
int CasADi__Sparsity__sizeU(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeU() );
}


// ================== Normal method: "sizeL" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sizeL"
// cWrapperName: "CasADi__Sparsity__sizeL"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__sizeL(CasADi::Sparsity* obj)"
// call: "obj->sizeL()"
extern "C"
    int CasADi__Sparsity__sizeL(CasADi::Sparsity* obj);
int CasADi__Sparsity__sizeL(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeL() );
}


// ================== Normal method: "sizeD" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sizeD"
// cWrapperName: "CasADi__Sparsity__sizeD"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__sizeD(CasADi::Sparsity* obj)"
// call: "obj->sizeD()"
extern "C"
    int CasADi__Sparsity__sizeD(CasADi::Sparsity* obj);
int CasADi__Sparsity__sizeD(CasADi::Sparsity* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeD() );
}


// ================== Normal method: "row" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::row"
// cWrapperName: "CasADi__Sparsity__row"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__row(CasADi::Sparsity* obj, int x0)"
// call: "obj->row(x0_)"
extern "C"
    int CasADi__Sparsity__row(CasADi::Sparsity* obj, int x0);
int CasADi__Sparsity__row(CasADi::Sparsity* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->row(x0_) );
}


// ================== Normal method: "colind" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::colind"
// cWrapperName: "CasADi__Sparsity__colind"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__colind(CasADi::Sparsity* obj, int x0)"
// call: "obj->colind(x0_)"
extern "C"
    int CasADi__Sparsity__colind(CasADi::Sparsity* obj, int x0);
int CasADi__Sparsity__colind(CasADi::Sparsity* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->colind(x0_) );
}


// ================== Normal method: "getCol" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getCol"
// cWrapperName: "CasADi__Sparsity__getCol"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__getCol(CasADi::Sparsity* obj)"
// call: "obj->getCol()"
extern "C"
    std::vector< int >* CasADi__Sparsity__getCol(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__getCol(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getCol() );
}


// ================== Normal method: "resize" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::resize"
// cWrapperName: "CasADi__Sparsity__resize"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__resize(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__resize(CasADi::Sparsity* obj, int x0, int x1);
void CasADi__Sparsity__resize(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
}


// ================== Normal method: "reshape" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::reshape"
// cWrapperName: "CasADi__Sparsity__reshape"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__reshape(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->reshape(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__reshape(CasADi::Sparsity* obj, int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__reshape(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->reshape(x0_, x1_) );
}


// ================== Normal method: "getNZ" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getNZ"
// cWrapperName: "CasADi__Sparsity__getNZ"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__getNZ(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->getNZ(x0_, x1_)"
extern "C"
    int CasADi__Sparsity__getNZ(CasADi::Sparsity* obj, int x0, int x1);
int CasADi__Sparsity__getNZ(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( obj->getNZ(x0_, x1_) );
}


// ================== Normal method: "getNZ'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getNZ'"
// cWrapperName: "CasADi__Sparsity__getNZ_TIC"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__getNZ_TIC(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->getNZ(x0_, x1_)"
extern "C"
    int CasADi__Sparsity__getNZ_TIC(CasADi::Sparsity* obj, int x0, int x1);
int CasADi__Sparsity__getNZ_TIC(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( obj->getNZ(x0_, x1_) );
}


// ================== Normal method: "hasNZ" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::hasNZ"
// cWrapperName: "CasADi__Sparsity__hasNZ"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__hasNZ(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
extern "C"
    int CasADi__Sparsity__hasNZ(CasADi::Sparsity* obj, int x0, int x1);
int CasADi__Sparsity__hasNZ(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( obj->hasNZ(x0_, x1_) );
}


// ================== Normal method: "getNZ''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getNZ''"
// cWrapperName: "CasADi__Sparsity__getNZ_TIC_TIC"
// protoArgs: "(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_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getNZ(x0_, x1_)"
extern "C"
    std::vector< int >* CasADi__Sparsity__getNZ_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
std::vector< int >* CasADi__Sparsity__getNZ_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    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);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getNZ(x0_, x1_) );
}


// ================== Normal method: "getNZInplace" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getNZInplace"
// cWrapperName: "CasADi__Sparsity__getNZInplace"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__getNZInplace(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->getNZInplace(x0_)"
extern "C"
    void CasADi__Sparsity__getNZInplace(CasADi::Sparsity* obj, std::vector< int >* x0);
void CasADi__Sparsity__getNZInplace(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->getNZInplace(x0_);
}


// ================== Normal method: "getLowerNZ" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getLowerNZ"
// cWrapperName: "CasADi__Sparsity__getLowerNZ"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__getLowerNZ(CasADi::Sparsity* obj)"
// call: "obj->getLowerNZ()"
extern "C"
    std::vector< int >* CasADi__Sparsity__getLowerNZ(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__getLowerNZ(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getLowerNZ() );
}


// ================== Normal method: "getUpperNZ" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getUpperNZ"
// cWrapperName: "CasADi__Sparsity__getUpperNZ"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__getUpperNZ(CasADi::Sparsity* obj)"
// call: "obj->getUpperNZ()"
extern "C"
    std::vector< int >* CasADi__Sparsity__getUpperNZ(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__getUpperNZ(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getUpperNZ() );
}


// ================== Normal method: "getCCS" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getCCS"
// cWrapperName: "CasADi__Sparsity__getCCS"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__getCCS(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getCCS(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__getCCS(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Sparsity__getCCS(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "getCRS" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getCRS"
// cWrapperName: "CasADi__Sparsity__getCRS"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__getCRS(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getCRS(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__getCRS(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Sparsity__getCRS(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "getTriplet" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getTriplet"
// cWrapperName: "CasADi__Sparsity__getTriplet"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__getTriplet(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->getTriplet(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__getTriplet(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Sparsity__getTriplet(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "sub" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::sub"
// cWrapperName: "CasADi__Sparsity__sub"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__sub(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->sub(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__sub(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
CasADi::Sparsity* CasADi__Sparsity__sub(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sub(x0_, x1_, x2_) );
}


// ================== Normal method: "transpose" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::transpose"
// cWrapperName: "CasADi__Sparsity__transpose"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__transpose(CasADi::Sparsity* obj)"
// call: "obj->transpose()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__transpose(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__transpose(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->transpose() );
}


// ================== Normal method: "transpose'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::transpose'"
// cWrapperName: "CasADi__Sparsity__transpose_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__transpose_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1)"
// call: "obj->transpose(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__transpose_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__transpose_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->transpose(x0_, x1_) );
}


// ================== Normal method: "transpose''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::transpose''"
// cWrapperName: "CasADi__Sparsity__transpose_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__transpose_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->transpose(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__transpose_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0);
CasADi::Sparsity* CasADi__Sparsity__transpose_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->transpose(x0_) );
}


// ================== Normal method: "isTranspose" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isTranspose"
// cWrapperName: "CasADi__Sparsity__isTranspose"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isTranspose(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->isTranspose(x0_)"
extern "C"
    int CasADi__Sparsity__isTranspose(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
int CasADi__Sparsity__isTranspose(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isTranspose(x0_) );
}


// ================== Normal method: "isReshape" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isReshape"
// cWrapperName: "CasADi__Sparsity__isReshape"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isReshape(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->isReshape(x0_)"
extern "C"
    int CasADi__Sparsity__isReshape(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
int CasADi__Sparsity__isReshape(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isReshape(x0_) );
}


// ================== Normal method: "patternCombine" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternCombine"
// cWrapperName: "CasADi__Sparsity__patternCombine"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternCombine(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3)"
// call: "obj->patternCombine(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternCombine(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3);
CasADi::Sparsity* CasADi__Sparsity__patternCombine(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2, std::vector< unsigned char >* x3){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternCombine(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "patternCombine'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternCombine'"
// cWrapperName: "CasADi__Sparsity__patternCombine_TIC"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternCombine_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2)"
// call: "obj->patternCombine(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternCombine_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2);
CasADi::Sparsity* CasADi__Sparsity__patternCombine_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1, int x2){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternCombine(x0_, x1_, x2_) );
}


// ================== Normal method: "patternUnion" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternUnion"
// cWrapperName: "CasADi__Sparsity__patternUnion"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternUnion(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1)"
// call: "obj->patternUnion(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternUnion(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1);
CasADi::Sparsity* CasADi__Sparsity__patternUnion(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< unsigned char > x1_ = Marshaling<std::vector< unsigned char >,std::vector< unsigned char >*>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternUnion(x0_, x1_) );
}


// ================== Normal method: "patternUnion'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternUnion'"
// cWrapperName: "CasADi__Sparsity__patternUnion_TIC"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternUnion_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->patternUnion(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternUnion_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__Sparsity__patternUnion_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternUnion(x0_) );
}


// ================== Normal method: "operator +" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::operator +"
// cWrapperName: "CasADi__Sparsity__operator_plus"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__operator_plus(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->operator +(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__operator_plus(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__Sparsity__operator_plus(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->operator +(x0_) );
}


// ================== Normal method: "patternIntersection" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternIntersection"
// cWrapperName: "CasADi__Sparsity__patternIntersection"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternIntersection(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1)"
// call: "obj->patternIntersection(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternIntersection(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1);
CasADi::Sparsity* CasADi__Sparsity__patternIntersection(CasADi::Sparsity* obj, CasADi::Sparsity* x0, std::vector< unsigned char >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< unsigned char > x1_ = Marshaling<std::vector< unsigned char >,std::vector< unsigned char >*>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternIntersection(x0_, x1_) );
}


// ================== Normal method: "patternIntersection'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternIntersection'"
// cWrapperName: "CasADi__Sparsity__patternIntersection_TIC"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternIntersection_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->patternIntersection(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternIntersection_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__Sparsity__patternIntersection_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternIntersection(x0_) );
}


// ================== Normal method: "operator *" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::operator *"
// cWrapperName: "CasADi__Sparsity__operator_mul"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__operator_mul(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->operator *(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__operator_mul(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__Sparsity__operator_mul(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->operator *(x0_) );
}


// ================== Normal method: "patternProduct" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternProduct"
// cWrapperName: "CasADi__Sparsity__patternProduct"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternProduct(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->patternProduct(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternProduct(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__Sparsity__patternProduct(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternProduct(x0_) );
}


// ================== Normal method: "patternInverse" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::patternInverse"
// cWrapperName: "CasADi__Sparsity__patternInverse"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__patternInverse(CasADi::Sparsity* obj)"
// call: "obj->patternInverse()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__patternInverse(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__patternInverse(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->patternInverse() );
}


// ================== Normal method: "enlarge" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::enlarge"
// cWrapperName: "CasADi__Sparsity__enlarge"
// protoArgs: "(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(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Sparsity__enlarge(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void CasADi__Sparsity__enlarge(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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_);
}


// ================== Normal method: "enlargeRows" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::enlargeRows"
// cWrapperName: "CasADi__Sparsity__enlargeRows"
// protoArgs: "(CasADi::Sparsity* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__enlargeRows(CasADi::Sparsity* obj, int x0, std::vector< int >* x1)"
// call: "obj->enlargeRows(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__enlargeRows(CasADi::Sparsity* obj, int x0, std::vector< int >* x1);
void CasADi__Sparsity__enlargeRows(CasADi::Sparsity* obj, int x0, std::vector< int >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->enlargeRows(x0_, x1_);
}


// ================== Normal method: "enlargeColumns" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::enlargeColumns"
// cWrapperName: "CasADi__Sparsity__enlargeColumns"
// protoArgs: "(CasADi::Sparsity* obj, int x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__enlargeColumns(CasADi::Sparsity* obj, int x0, std::vector< int >* x1)"
// call: "obj->enlargeColumns(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__enlargeColumns(CasADi::Sparsity* obj, int x0, std::vector< int >* x1);
void CasADi__Sparsity__enlargeColumns(CasADi::Sparsity* obj, int x0, std::vector< int >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    obj->enlargeColumns(x0_, x1_);
}


// ================== Normal method: "makeDense" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::makeDense"
// cWrapperName: "CasADi__Sparsity__makeDense"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__makeDense(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->makeDense(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__makeDense(CasADi::Sparsity* obj, std::vector< int >* x0);
CasADi::Sparsity* CasADi__Sparsity__makeDense(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->makeDense(x0_) );
}


// ================== Normal method: "erase" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::erase"
// cWrapperName: "CasADi__Sparsity__erase"
// protoArgs: "(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(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
extern "C"
    std::vector< int >* CasADi__Sparsity__erase(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
std::vector< int >* CasADi__Sparsity__erase(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    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);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->erase(x0_, x1_) );
}


// ================== Normal method: "append" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::append"
// cWrapperName: "CasADi__Sparsity__append"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__append(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->append(x0_)"
extern "C"
    void CasADi__Sparsity__append(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
void CasADi__Sparsity__append(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    obj->append(x0_);
}


// ================== Normal method: "appendColumns" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::appendColumns"
// cWrapperName: "CasADi__Sparsity__appendColumns"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__appendColumns(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->appendColumns(x0_)"
extern "C"
    void CasADi__Sparsity__appendColumns(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
void CasADi__Sparsity__appendColumns(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    obj->appendColumns(x0_);
}


// ================== Normal method: "reserve" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::reserve"
// cWrapperName: "CasADi__Sparsity__reserve"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__reserve(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__reserve(CasADi::Sparsity* obj, int x0, int x1);
void CasADi__Sparsity__reserve(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
}


// ================== Normal method: "isScalar" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isScalar"
// cWrapperName: "CasADi__Sparsity__isScalar"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isScalar(CasADi::Sparsity* obj, int x0)"
// call: "obj->isScalar(x0_)"
extern "C"
    int CasADi__Sparsity__isScalar(CasADi::Sparsity* obj, int x0);
int CasADi__Sparsity__isScalar(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar(x0_) );
}


// ================== Normal method: "isScalar'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isScalar'"
// cWrapperName: "CasADi__Sparsity__isScalar_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isScalar_TIC(CasADi::Sparsity* obj)"
// call: "obj->isScalar()"
extern "C"
    int CasADi__Sparsity__isScalar_TIC(CasADi::Sparsity* obj);
int CasADi__Sparsity__isScalar_TIC(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar() );
}


// ================== Normal method: "isDense" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isDense"
// cWrapperName: "CasADi__Sparsity__isDense"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isDense(CasADi::Sparsity* obj)"
// call: "obj->isDense()"
extern "C"
    int CasADi__Sparsity__isDense(CasADi::Sparsity* obj);
int CasADi__Sparsity__isDense(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDense() );
}


// ================== Normal method: "isVector" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isVector"
// cWrapperName: "CasADi__Sparsity__isVector"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isVector(CasADi::Sparsity* obj)"
// call: "obj->isVector()"
extern "C"
    int CasADi__Sparsity__isVector(CasADi::Sparsity* obj);
int CasADi__Sparsity__isVector(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isVector() );
}


// ================== Normal method: "isDiagonal" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isDiagonal"
// cWrapperName: "CasADi__Sparsity__isDiagonal"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isDiagonal(CasADi::Sparsity* obj)"
// call: "obj->isDiagonal()"
extern "C"
    int CasADi__Sparsity__isDiagonal(CasADi::Sparsity* obj);
int CasADi__Sparsity__isDiagonal(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDiagonal() );
}


// ================== Normal method: "isSquare" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isSquare"
// cWrapperName: "CasADi__Sparsity__isSquare"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isSquare(CasADi::Sparsity* obj)"
// call: "obj->isSquare()"
extern "C"
    int CasADi__Sparsity__isSquare(CasADi::Sparsity* obj);
int CasADi__Sparsity__isSquare(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSquare() );
}


// ================== Normal method: "isSymmetric" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isSymmetric"
// cWrapperName: "CasADi__Sparsity__isSymmetric"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isSymmetric(CasADi::Sparsity* obj)"
// call: "obj->isSymmetric()"
extern "C"
    int CasADi__Sparsity__isSymmetric(CasADi::Sparsity* obj);
int CasADi__Sparsity__isSymmetric(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymmetric() );
}


// ================== Normal method: "isTriu" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isTriu"
// cWrapperName: "CasADi__Sparsity__isTriu"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isTriu(CasADi::Sparsity* obj)"
// call: "obj->isTriu()"
extern "C"
    int CasADi__Sparsity__isTriu(CasADi::Sparsity* obj);
int CasADi__Sparsity__isTriu(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTriu() );
}


// ================== Normal method: "isTril" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isTril"
// cWrapperName: "CasADi__Sparsity__isTril"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isTril(CasADi::Sparsity* obj)"
// call: "obj->isTril()"
extern "C"
    int CasADi__Sparsity__isTril(CasADi::Sparsity* obj);
int CasADi__Sparsity__isTril(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTril() );
}


// ================== Normal method: "isSingular" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::isSingular"
// cWrapperName: "CasADi__Sparsity__isSingular"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__isSingular(CasADi::Sparsity* obj)"
// call: "obj->isSingular()"
extern "C"
    int CasADi__Sparsity__isSingular(CasADi::Sparsity* obj);
int CasADi__Sparsity__isSingular(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSingular() );
}


// ================== Normal method: "getTriu" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getTriu"
// cWrapperName: "CasADi__Sparsity__getTriu"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__getTriu(CasADi::Sparsity* obj, int x0)"
// call: "obj->getTriu(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__getTriu(CasADi::Sparsity* obj, int x0);
CasADi::Sparsity* CasADi__Sparsity__getTriu(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getTriu(x0_) );
}


// ================== Normal method: "getTriu'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getTriu'"
// cWrapperName: "CasADi__Sparsity__getTriu_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__getTriu_TIC(CasADi::Sparsity* obj)"
// call: "obj->getTriu()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__getTriu_TIC(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__getTriu_TIC(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getTriu() );
}


// ================== Normal method: "getTril" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getTril"
// cWrapperName: "CasADi__Sparsity__getTril"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__getTril(CasADi::Sparsity* obj, int x0)"
// call: "obj->getTril(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__getTril(CasADi::Sparsity* obj, int x0);
CasADi::Sparsity* CasADi__Sparsity__getTril(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getTril(x0_) );
}


// ================== Normal method: "getTril'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getTril'"
// cWrapperName: "CasADi__Sparsity__getTril_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__getTril_TIC(CasADi::Sparsity* obj)"
// call: "obj->getTril()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__getTril_TIC(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__getTril_TIC(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->getTril() );
}


// ================== Normal method: "rowsSequential" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::rowsSequential"
// cWrapperName: "CasADi__Sparsity__rowsSequential"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__rowsSequential(CasADi::Sparsity* obj, int x0)"
// call: "obj->rowsSequential(x0_)"
extern "C"
    int CasADi__Sparsity__rowsSequential(CasADi::Sparsity* obj, int x0);
int CasADi__Sparsity__rowsSequential(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->rowsSequential(x0_) );
}


// ================== Normal method: "rowsSequential'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::rowsSequential'"
// cWrapperName: "CasADi__Sparsity__rowsSequential_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__rowsSequential_TIC(CasADi::Sparsity* obj)"
// call: "obj->rowsSequential()"
extern "C"
    int CasADi__Sparsity__rowsSequential_TIC(CasADi::Sparsity* obj);
int CasADi__Sparsity__rowsSequential_TIC(CasADi::Sparsity* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->rowsSequential() );
}


// ================== Normal method: "removeDuplicates" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::removeDuplicates"
// cWrapperName: "CasADi__Sparsity__removeDuplicates"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__removeDuplicates(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->removeDuplicates(x0_)"
extern "C"
    void CasADi__Sparsity__removeDuplicates(CasADi::Sparsity* obj, std::vector< int >* x0);
void CasADi__Sparsity__removeDuplicates(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->removeDuplicates(x0_);
}


// ================== Normal method: "eliminationTree" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::eliminationTree"
// cWrapperName: "CasADi__Sparsity__eliminationTree"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__eliminationTree(CasADi::Sparsity* obj, int x0)"
// call: "obj->eliminationTree(x0_)"
extern "C"
    std::vector< int >* CasADi__Sparsity__eliminationTree(CasADi::Sparsity* obj, int x0);
std::vector< int >* CasADi__Sparsity__eliminationTree(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->eliminationTree(x0_) );
}


// ================== Normal method: "eliminationTree'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::eliminationTree'"
// cWrapperName: "CasADi__Sparsity__eliminationTree_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__eliminationTree_TIC(CasADi::Sparsity* obj)"
// call: "obj->eliminationTree()"
extern "C"
    std::vector< int >* CasADi__Sparsity__eliminationTree_TIC(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__eliminationTree_TIC(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->eliminationTree() );
}


// ================== Normal method: "depthFirstSearch" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::depthFirstSearch"
// cWrapperName: "CasADi__Sparsity__depthFirstSearch"
// protoArgs: "(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(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_)"
extern "C"
    int CasADi__Sparsity__depthFirstSearch(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(CasADi::Sparsity* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3, std::vector< int >* x4, std::vector< int >* x5){
    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);

    return WrapReturn< int, int >::wrapReturn( obj->depthFirstSearch(x0_, x1_, x2_, x3_, x4_, x5_) );
}


// ================== Normal method: "stronglyConnectedComponents" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::stronglyConnectedComponents"
// cWrapperName: "CasADi__Sparsity__stronglyConnectedComponents"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Sparsity__stronglyConnectedComponents(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->stronglyConnectedComponents(x0_, x1_)"
extern "C"
    int CasADi__Sparsity__stronglyConnectedComponents(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1);
int CasADi__Sparsity__stronglyConnectedComponents(CasADi::Sparsity* obj, std::vector< int >* x0, std::vector< int >* x1){
    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);

    return WrapReturn< int, int >::wrapReturn( obj->stronglyConnectedComponents(x0_, x1_) );
}


// ================== Normal method: "dulmageMendelsohn" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::dulmageMendelsohn"
// cWrapperName: "CasADi__Sparsity__dulmageMendelsohn"
// protoArgs: "(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(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_)"
extern "C"
    int CasADi__Sparsity__dulmageMendelsohn(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(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){
    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);

    return WrapReturn< int, int >::wrapReturn( obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_, x6_) );
}


// ================== Normal method: "dulmageMendelsohn'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::dulmageMendelsohn'"
// cWrapperName: "CasADi__Sparsity__dulmageMendelsohn_TIC"
// protoArgs: "(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_TIC(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_)"
extern "C"
    int CasADi__Sparsity__dulmageMendelsohn_TIC(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_TIC(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){
    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);

    return WrapReturn< int, int >::wrapReturn( obj->dulmageMendelsohn(x0_, x1_, x2_, x3_, x4_, x5_) );
}


// ================== Normal method: "getElements" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getElements"
// cWrapperName: "CasADi__Sparsity__getElements"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__getElements(CasADi::Sparsity* obj, int x0)"
// call: "obj->getElements(x0_)"
extern "C"
    std::vector< int >* CasADi__Sparsity__getElements(CasADi::Sparsity* obj, int x0);
std::vector< int >* CasADi__Sparsity__getElements(CasADi::Sparsity* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getElements(x0_) );
}


// ================== Normal method: "getElements'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getElements'"
// cWrapperName: "CasADi__Sparsity__getElements_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__getElements_TIC(CasADi::Sparsity* obj)"
// call: "obj->getElements()"
extern "C"
    std::vector< int >* CasADi__Sparsity__getElements_TIC(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__getElements_TIC(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getElements() );
}


// ================== Normal method: "getElements''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getElements''"
// cWrapperName: "CasADi__Sparsity__getElements_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__getElements_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1)"
// call: "obj->getElements(x0_, x1_)"
extern "C"
    void CasADi__Sparsity__getElements_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1);
void CasADi__Sparsity__getElements_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    obj->getElements(x0_, x1_);
}


// ================== Normal method: "getElements'''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::getElements'''"
// cWrapperName: "CasADi__Sparsity__getElements_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__getElements_TIC_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->getElements(x0_)"
extern "C"
    void CasADi__Sparsity__getElements_TIC_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0);
void CasADi__Sparsity__getElements_TIC_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->getElements(x0_);
}


// ================== Normal method: "unidirectionalColoring" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::unidirectionalColoring"
// cWrapperName: "CasADi__Sparsity__unidirectionalColoring"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1)"
// call: "obj->unidirectionalColoring(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring(CasADi::Sparsity* obj, CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->unidirectionalColoring(x0_, x1_) );
}


// ================== Normal method: "unidirectionalColoring'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::unidirectionalColoring'"
// cWrapperName: "CasADi__Sparsity__unidirectionalColoring_TIC"
// protoArgs: "(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0)"
// call: "obj->unidirectionalColoring(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring_TIC(CasADi::Sparsity* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->unidirectionalColoring(x0_) );
}


// ================== Normal method: "unidirectionalColoring''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::unidirectionalColoring''"
// cWrapperName: "CasADi__Sparsity__unidirectionalColoring_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring_TIC_TIC(CasADi::Sparsity* obj)"
// call: "obj->unidirectionalColoring()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring_TIC_TIC(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__unidirectionalColoring_TIC_TIC(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->unidirectionalColoring() );
}


// ================== Normal method: "starColoring" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::starColoring"
// cWrapperName: "CasADi__Sparsity__starColoring"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__starColoring(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->starColoring(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__starColoring(CasADi::Sparsity* obj, int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__starColoring(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->starColoring(x0_, x1_) );
}


// ================== Normal method: "starColoring'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::starColoring'"
// cWrapperName: "CasADi__Sparsity__starColoring_TIC"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__starColoring_TIC(CasADi::Sparsity* obj, int x0)"
// call: "obj->starColoring(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__starColoring_TIC(CasADi::Sparsity* obj, int x0);
CasADi::Sparsity* CasADi__Sparsity__starColoring_TIC(CasADi::Sparsity* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->starColoring(x0_) );
}


// ================== Normal method: "starColoring''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::starColoring''"
// cWrapperName: "CasADi__Sparsity__starColoring_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__starColoring_TIC_TIC(CasADi::Sparsity* obj)"
// call: "obj->starColoring()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__starColoring_TIC_TIC(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__starColoring_TIC_TIC(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->starColoring() );
}


// ================== Normal method: "starColoring2" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::starColoring2"
// cWrapperName: "CasADi__Sparsity__starColoring2"
// protoArgs: "(CasADi::Sparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__starColoring2(CasADi::Sparsity* obj, int x0, int x1)"
// call: "obj->starColoring2(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__starColoring2(CasADi::Sparsity* obj, int x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__starColoring2(CasADi::Sparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->starColoring2(x0_, x1_) );
}


// ================== Normal method: "starColoring2'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::starColoring2'"
// cWrapperName: "CasADi__Sparsity__starColoring2_TIC"
// protoArgs: "(CasADi::Sparsity* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__starColoring2_TIC(CasADi::Sparsity* obj, int x0)"
// call: "obj->starColoring2(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__starColoring2_TIC(CasADi::Sparsity* obj, int x0);
CasADi::Sparsity* CasADi__Sparsity__starColoring2_TIC(CasADi::Sparsity* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->starColoring2(x0_) );
}


// ================== Normal method: "starColoring2''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::starColoring2''"
// cWrapperName: "CasADi__Sparsity__starColoring2_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__starColoring2_TIC_TIC(CasADi::Sparsity* obj)"
// call: "obj->starColoring2()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__starColoring2_TIC_TIC(CasADi::Sparsity* obj);
CasADi::Sparsity* CasADi__Sparsity__starColoring2_TIC_TIC(CasADi::Sparsity* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->starColoring2() );
}


// ================== Normal method: "largestFirstOrdering" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::largestFirstOrdering"
// cWrapperName: "CasADi__Sparsity__largestFirstOrdering"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Sparsity__largestFirstOrdering(CasADi::Sparsity* obj)"
// call: "obj->largestFirstOrdering()"
extern "C"
    std::vector< int >* CasADi__Sparsity__largestFirstOrdering(CasADi::Sparsity* obj);
std::vector< int >* CasADi__Sparsity__largestFirstOrdering(CasADi::Sparsity* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->largestFirstOrdering() );
}


// ================== Normal method: "pmult" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::pmult"
// cWrapperName: "CasADi__Sparsity__pmult"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__pmult(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3)"
// call: "obj->pmult(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__pmult(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3);
CasADi::Sparsity* CasADi__Sparsity__pmult(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2, int x3){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->pmult(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "pmult'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::pmult'"
// cWrapperName: "CasADi__Sparsity__pmult_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__pmult_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2)"
// call: "obj->pmult(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__pmult_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2);
CasADi::Sparsity* CasADi__Sparsity__pmult_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->pmult(x0_, x1_, x2_) );
}


// ================== Normal method: "pmult''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::pmult''"
// cWrapperName: "CasADi__Sparsity__pmult_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__pmult_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1)"
// call: "obj->pmult(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__pmult_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1);
CasADi::Sparsity* CasADi__Sparsity__pmult_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0, int x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->pmult(x0_, x1_) );
}


// ================== Normal method: "pmult'''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::pmult'''"
// cWrapperName: "CasADi__Sparsity__pmult_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__pmult_TIC_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0)"
// call: "obj->pmult(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__pmult_TIC_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0);
CasADi::Sparsity* CasADi__Sparsity__pmult_TIC_TIC_TIC(CasADi::Sparsity* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->pmult(x0_) );
}


// ================== Normal method: "dimString" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::dimString"
// cWrapperName: "CasADi__Sparsity__dimString"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Sparsity__dimString(CasADi::Sparsity* obj)"
// call: "obj->dimString()"
extern "C"
    std::string* CasADi__Sparsity__dimString(CasADi::Sparsity* obj);
std::string* CasADi__Sparsity__dimString(CasADi::Sparsity* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->dimString() );
}


// ================== Normal method: "spy'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::spy'"
// cWrapperName: "CasADi__Sparsity__spy_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__spy_TIC(CasADi::Sparsity* obj)"
// call: "obj->spy()"
extern "C"
    void CasADi__Sparsity__spy_TIC(CasADi::Sparsity* obj);
void CasADi__Sparsity__spy_TIC(CasADi::Sparsity* obj){

    obj->spy();
}


// ================== Normal method: "spyMatlab" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::spyMatlab"
// cWrapperName: "CasADi__Sparsity__spyMatlab"
// protoArgs: "(CasADi::Sparsity* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__spyMatlab(CasADi::Sparsity* obj, std::string* x0)"
// call: "obj->spyMatlab(x0_)"
extern "C"
    void CasADi__Sparsity__spyMatlab(CasADi::Sparsity* obj, std::string* x0);
void CasADi__Sparsity__spyMatlab(CasADi::Sparsity* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->spyMatlab(x0_);
}


// ================== Normal method: "printCompact'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::printCompact'"
// cWrapperName: "CasADi__Sparsity__printCompact_TIC"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Sparsity__printCompact_TIC(CasADi::Sparsity* obj)"
// call: "obj->printCompact()"
extern "C"
    void CasADi__Sparsity__printCompact_TIC(CasADi::Sparsity* obj);
void CasADi__Sparsity__printCompact_TIC(CasADi::Sparsity* obj){

    obj->printCompact();
}


// ================== Normal method: "hash" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity::hash"
// cWrapperName: "CasADi__Sparsity__hash"
// protoArgs: "(CasADi::Sparsity* obj)"
// args: "()"
// rettype: CSize
// cWrapperRetType: "size_t"
// proto: "size_t CasADi__Sparsity__hash(CasADi::Sparsity* obj)"
// call: "obj->hash()"
extern "C"
    size_t CasADi__Sparsity__hash(CasADi::Sparsity* obj);
size_t CasADi__Sparsity__hash(CasADi::Sparsity* obj){

    return WrapReturn< size_t, size_t >::wrapReturn( obj->hash() );
}


// ================== Constructor method: "Sparsity" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity"
// cWrapperName: "CasADi__Sparsity__Sparsity"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__Sparsity(int x0)"
// call: "CasADi::Sparsity(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__Sparsity(int x0);
CasADi::Sparsity* CasADi__Sparsity__Sparsity(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity(x0_) );
}


// ================== Constructor method: "Sparsity'" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity"
// cWrapperName: "CasADi__Sparsity__Sparsity_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__Sparsity_TIC()"
// call: "CasADi::Sparsity()"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__Sparsity_TIC();
CasADi::Sparsity* CasADi__Sparsity__Sparsity_TIC(){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity() );
}


// ================== Constructor method: "Sparsity''" ===============
// class: "CasADi::Sparsity"
// cppName: "CasADi::Sparsity"
// cWrapperName: "CasADi__Sparsity__Sparsity_TIC_TIC"
// protoArgs: "(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Sparsity__Sparsity_TIC_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "CasADi::Sparsity(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Sparsity__Sparsity_TIC_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
CasADi::Sparsity* CasADi__Sparsity__Sparsity_TIC_TIC(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::Sparsity(x0_, x1_, x2_, x3_) );
}


// ================== delete CasadiClass ExpMX===============
// classType: CasadiClass ExpMX
extern "C"
    void delete_CasADi__GenericExpression_CasADi__MX_(CasADi::GenericExpression< CasADi::MX >* obj);
void delete_CasADi__GenericExpression_CasADi__MX_(CasADi::GenericExpression< CasADi::MX >* obj){
    delete obj;
}

// ================== Normal method: "__mldivide__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__mldivide__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____mldivide__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____mldivide__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__mldivide__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____mldivide__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____mldivide__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__mldivide__(x0_) );
}


// ================== Normal method: "__gt__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__gt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____gt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____gt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__gt__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____gt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____gt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__gt__(x0_) );
}


// ================== Normal method: "__ge__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__ge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____ge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____ge__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__ge__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____ge__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____ge__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__ge__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__truediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____truediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____truediv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____truediv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____truediv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__radd__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__radd__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____radd__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____radd__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__radd__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____radd__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____radd__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__radd__(x0_) );
}


// ================== Normal method: "__rsub__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rsub__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rsub__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rsub__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rsub__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rsub__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rsub__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rsub__(x0_) );
}


// ================== Normal method: "__rmul__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rmul__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rmul__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rmul__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rmul__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rmul__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rmul__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rmul__(x0_) );
}


// ================== Normal method: "__rdiv__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rdiv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rdiv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rdiv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rdiv__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rdiv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rdiv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rdiv__(x0_) );
}


// ================== Normal method: "__rlt__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rlt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rlt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rlt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rlt__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rlt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rlt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rlt__(x0_) );
}


// ================== Normal method: "__rle__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rle__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rle__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rle__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rle__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rle__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rle__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rle__(x0_) );
}


// ================== Normal method: "__rgt__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rgt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rgt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rgt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rgt__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rgt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rgt__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rgt__(x0_) );
}


// ================== Normal method: "__rge__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rge__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rge__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rge__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rge__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rge__(x0_) );
}


// ================== Normal method: "__req__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__req__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____req__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____req__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__req__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____req__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____req__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__req__(x0_) );
}


// ================== Normal method: "__rne__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rne__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rne__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rne__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rne__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rne__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rne__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rne__(x0_) );
}


// ================== Normal method: "__rtruediv__" ===============
// class: "CasADi::GenericExpression< CasADi::MX >"
// cppName: "CasADi::GenericExpression< CasADi::MX >::__rtruediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__MX_____rtruediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rtruediv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0)"
// call: "obj->__rtruediv__(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rtruediv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0);
CasADi::MX* CasADi__GenericExpression_CasADi__MX_____rtruediv__(CasADi::GenericExpression< CasADi::MX >* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__rtruediv__(x0_) );
}


// ================== delete CasadiClass MX===============
// classType: CasadiClass MX
extern "C"
    void delete_CasADi__MX(CasADi::MX* obj);
void delete_CasADi__MX(CasADi::MX* obj){
    delete obj;
}

// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__nonzero__"
// cWrapperName: "CasADi__MX____nonzero__"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX____nonzero__(CasADi::MX* obj)"
// call: "obj->__nonzero__()"
extern "C"
    int CasADi__MX____nonzero__(CasADi::MX* obj);
int CasADi__MX____nonzero__(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->__nonzero__() );
}


// ================== 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: "(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__nz_indexed_one_based_assignment(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__nz_indexed_one_based_assignment(CasADi::MX* obj, int x0, CasADi::MX* x1);
void CasADi__MX__nz_indexed_one_based_assignment(CasADi::MX* obj, int x0, CasADi::MX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== 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: "(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__nz_indexed_zero_based_assignment(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__nz_indexed_zero_based_assignment(CasADi::MX* obj, int x0, CasADi::MX* x1);
void CasADi__MX__nz_indexed_zero_based_assignment(CasADi::MX* obj, int x0, CasADi::MX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nz_indexed_assignment"
// cWrapperName: "CasADi__MX__nz_indexed_assignment"
// protoArgs: "(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__nz_indexed_assignment(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__nz_indexed_assignment(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1);
void CasADi__MX__nz_indexed_assignment(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nz_indexed_assignment'"
// cWrapperName: "CasADi__MX__nz_indexed_assignment_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__nz_indexed_assignment_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__nz_indexed_assignment_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1);
void CasADi__MX__nz_indexed_assignment_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_one_based_assignment"
// cWrapperName: "CasADi__MX__indexed_one_based_assignment"
// protoArgs: "(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(CasADi::MX* obj, int x0, int x1, CasADi::MX* x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_one_based_assignment(CasADi::MX* obj, int x0, int x1, CasADi::MX* x2);
void CasADi__MX__indexed_one_based_assignment(CasADi::MX* obj, int x0, int x1, CasADi::MX* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_zero_based_assignment"
// cWrapperName: "CasADi__MX__indexed_zero_based_assignment"
// protoArgs: "(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(CasADi::MX* obj, int x0, int x1, CasADi::MX* x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_zero_based_assignment(CasADi::MX* obj, int x0, int x1, CasADi::MX* x2);
void CasADi__MX__indexed_zero_based_assignment(CasADi::MX* obj, int x0, int x1, CasADi::MX* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment"
// cWrapperName: "CasADi__MX__indexed_assignment"
// protoArgs: "(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::MX* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment'"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC"
// protoArgs: "(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_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::MX* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_zero_based_assignment'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_zero_based_assignment'"
// cWrapperName: "CasADi__MX__indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_zero_based_assignment_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__indexed_zero_based_assignment_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1);
void CasADi__MX__indexed_zero_based_assignment_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Sparsity* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC(CasADi::MX* obj, CasADi::Sparsity* x0, CasADi::MX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC(CasADi::MX* obj, CasADi::Sparsity* x0, CasADi::MX* x1);
void CasADi__MX__indexed_assignment_TIC_TIC(CasADi::MX* obj, CasADi::Sparsity* x0, CasADi::MX* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment'''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::MX* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment''''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment'''''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::MX* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment''''''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment'''''''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::MX* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_one_based_assignment'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_one_based_assignment'"
// cWrapperName: "CasADi__MX__indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_one_based_assignment_TIC(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__indexed_one_based_assignment_TIC(CasADi::MX* obj, int x0, CasADi::MX* x1);
void CasADi__MX__indexed_one_based_assignment_TIC(CasADi::MX* obj, int x0, CasADi::MX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_zero_based_assignment''"
// cWrapperName: "CasADi__MX__indexed_zero_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_zero_based_assignment_TIC_TIC(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__indexed_zero_based_assignment_TIC_TIC(CasADi::MX* obj, int x0, CasADi::MX* x1);
void CasADi__MX__indexed_zero_based_assignment_TIC_TIC(CasADi::MX* obj, int x0, CasADi::MX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment''''''''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::IndexList* x0, CasADi::MX* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment'''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::indexed_assignment'''''''''"
// cWrapperName: "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1);
void CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sparsityRef"
// cWrapperName: "CasADi__MX__sparsityRef"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__MX__sparsityRef(CasADi::MX* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__MX__sparsityRef(CasADi::MX* obj);
CasADi::Sparsity* CasADi__MX__sparsityRef(CasADi::MX* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Normal method: "erase" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::erase"
// cWrapperName: "CasADi__MX__erase"
// protoArgs: "(CasADi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__erase(CasADi::MX* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
extern "C"
    void CasADi__MX__erase(CasADi::MX* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__MX__erase(CasADi::MX* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "enlarge" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::enlarge"
// cWrapperName: "CasADi__MX__enlarge"
// protoArgs: "(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(CasADi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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_);
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::operator -"
// cWrapperName: "CasADi__MX__operator_minus"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__operator_minus(CasADi::MX* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::MX* CasADi__MX__operator_minus(CasADi::MX* obj);
CasADi::MX* CasADi__MX__operator_minus(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->operator -() );
}


// ================== Normal method: "getDep" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getDep"
// cWrapperName: "CasADi__MX__getDep"
// protoArgs: "(CasADi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getDep(CasADi::MX* obj, int x0)"
// call: "obj->getDep(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__getDep(CasADi::MX* obj, int x0);
CasADi::MX* CasADi__MX__getDep(CasADi::MX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getDep(x0_) );
}


// ================== Normal method: "getDep'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getDep'"
// cWrapperName: "CasADi__MX__getDep_TIC"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getDep_TIC(CasADi::MX* obj)"
// call: "obj->getDep()"
extern "C"
    CasADi::MX* CasADi__MX__getDep_TIC(CasADi::MX* obj);
CasADi::MX* CasADi__MX__getDep_TIC(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getDep() );
}


// ================== Normal method: "getNumOutputs" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNumOutputs"
// cWrapperName: "CasADi__MX__getNumOutputs"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getNumOutputs(CasADi::MX* obj)"
// call: "obj->getNumOutputs()"
extern "C"
    int CasADi__MX__getNumOutputs(CasADi::MX* obj);
int CasADi__MX__getNumOutputs(CasADi::MX* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumOutputs() );
}


// ================== Normal method: "getOutput" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getOutput"
// cWrapperName: "CasADi__MX__getOutput"
// protoArgs: "(CasADi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getOutput(CasADi::MX* obj, int x0)"
// call: "obj->getOutput(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__getOutput(CasADi::MX* obj, int x0);
CasADi::MX* CasADi__MX__getOutput(CasADi::MX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getOutput(x0_) );
}


// ================== Normal method: "getOutput'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getOutput'"
// cWrapperName: "CasADi__MX__getOutput_TIC"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getOutput_TIC(CasADi::MX* obj)"
// call: "obj->getOutput()"
extern "C"
    CasADi::MX* CasADi__MX__getOutput_TIC(CasADi::MX* obj);
CasADi::MX* CasADi__MX__getOutput_TIC(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getOutput() );
}


// ================== Normal method: "getNdeps" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNdeps"
// cWrapperName: "CasADi__MX__getNdeps"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getNdeps(CasADi::MX* obj)"
// call: "obj->getNdeps()"
extern "C"
    int CasADi__MX__getNdeps(CasADi::MX* obj);
int CasADi__MX__getNdeps(CasADi::MX* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNdeps() );
}


// ================== Normal method: "getName" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getName"
// cWrapperName: "CasADi__MX__getName"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__MX__getName(CasADi::MX* obj)"
// call: "obj->getName()"
extern "C"
    std::string* CasADi__MX__getName(CasADi::MX* obj);
std::string* CasADi__MX__getName(CasADi::MX* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getName() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getValue"
// cWrapperName: "CasADi__MX__getValue"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__MX__getValue(CasADi::MX* obj)"
// call: "obj->getValue()"
extern "C"
    double CasADi__MX__getValue(CasADi::MX* obj);
double CasADi__MX__getValue(CasADi::MX* obj){

    return WrapReturn< double, double >::wrapReturn( obj->getValue() );
}


// ================== Normal method: "getMatrixValue" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getMatrixValue"
// cWrapperName: "CasADi__MX__getMatrixValue"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__MX__getMatrixValue(CasADi::MX* obj)"
// call: "obj->getMatrixValue()"
extern "C"
    CasADi::Matrix< double >* CasADi__MX__getMatrixValue(CasADi::MX* obj);
CasADi::Matrix< double >* CasADi__MX__getMatrixValue(CasADi::MX* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getMatrixValue() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isSymbolic"
// cWrapperName: "CasADi__MX__isSymbolic"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isSymbolic(CasADi::MX* obj)"
// call: "obj->isSymbolic()"
extern "C"
    int CasADi__MX__isSymbolic(CasADi::MX* obj);
int CasADi__MX__isSymbolic(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolic() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isConstant"
// cWrapperName: "CasADi__MX__isConstant"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isConstant(CasADi::MX* obj)"
// call: "obj->isConstant()"
extern "C"
    int CasADi__MX__isConstant(CasADi::MX* obj);
int CasADi__MX__isConstant(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isConstant() );
}


// ================== Normal method: "isEvaluation" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isEvaluation"
// cWrapperName: "CasADi__MX__isEvaluation"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isEvaluation(CasADi::MX* obj)"
// call: "obj->isEvaluation()"
extern "C"
    int CasADi__MX__isEvaluation(CasADi::MX* obj);
int CasADi__MX__isEvaluation(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEvaluation() );
}


// ================== Normal method: "isEvaluationOutput" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isEvaluationOutput"
// cWrapperName: "CasADi__MX__isEvaluationOutput"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isEvaluationOutput(CasADi::MX* obj)"
// call: "obj->isEvaluationOutput()"
extern "C"
    int CasADi__MX__isEvaluationOutput(CasADi::MX* obj);
int CasADi__MX__isEvaluationOutput(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEvaluationOutput() );
}


// ================== Normal method: "getEvaluationOutput" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getEvaluationOutput"
// cWrapperName: "CasADi__MX__getEvaluationOutput"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getEvaluationOutput(CasADi::MX* obj)"
// call: "obj->getEvaluationOutput()"
extern "C"
    int CasADi__MX__getEvaluationOutput(CasADi::MX* obj);
int CasADi__MX__getEvaluationOutput(CasADi::MX* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getEvaluationOutput() );
}


// ================== Normal method: "isOperation" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isOperation"
// cWrapperName: "CasADi__MX__isOperation"
// protoArgs: "(CasADi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isOperation(CasADi::MX* obj, int x0)"
// call: "obj->isOperation(x0_)"
extern "C"
    int CasADi__MX__isOperation(CasADi::MX* obj, int x0);
int CasADi__MX__isOperation(CasADi::MX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isOperation(x0_) );
}


// ================== Normal method: "isMultiplication" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isMultiplication"
// cWrapperName: "CasADi__MX__isMultiplication"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isMultiplication(CasADi::MX* obj)"
// call: "obj->isMultiplication()"
extern "C"
    int CasADi__MX__isMultiplication(CasADi::MX* obj);
int CasADi__MX__isMultiplication(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMultiplication() );
}


// ================== Normal method: "isCommutative" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isCommutative"
// cWrapperName: "CasADi__MX__isCommutative"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isCommutative(CasADi::MX* obj)"
// call: "obj->isCommutative()"
extern "C"
    int CasADi__MX__isCommutative(CasADi::MX* obj);
int CasADi__MX__isCommutative(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isCommutative() );
}


// ================== Normal method: "isNorm" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isNorm"
// cWrapperName: "CasADi__MX__isNorm"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isNorm(CasADi::MX* obj)"
// call: "obj->isNorm()"
extern "C"
    int CasADi__MX__isNorm(CasADi::MX* obj);
int CasADi__MX__isNorm(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isNorm() );
}


// ================== Normal method: "isSymbolicSparse" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isSymbolicSparse"
// cWrapperName: "CasADi__MX__isSymbolicSparse"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isSymbolicSparse(CasADi::MX* obj)"
// call: "obj->isSymbolicSparse()"
extern "C"
    int CasADi__MX__isSymbolicSparse(CasADi::MX* obj);
int CasADi__MX__isSymbolicSparse(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolicSparse() );
}


// ================== Normal method: "isIdentity" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isIdentity"
// cWrapperName: "CasADi__MX__isIdentity"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isIdentity(CasADi::MX* obj)"
// call: "obj->isIdentity()"
extern "C"
    int CasADi__MX__isIdentity(CasADi::MX* obj);
int CasADi__MX__isIdentity(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isIdentity() );
}


// ================== Normal method: "isZero" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isZero"
// cWrapperName: "CasADi__MX__isZero"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isZero(CasADi::MX* obj)"
// call: "obj->isZero()"
extern "C"
    int CasADi__MX__isZero(CasADi::MX* obj);
int CasADi__MX__isZero(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isZero() );
}


// ================== Normal method: "isOne" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isOne"
// cWrapperName: "CasADi__MX__isOne"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isOne(CasADi::MX* obj)"
// call: "obj->isOne()"
extern "C"
    int CasADi__MX__isOne(CasADi::MX* obj);
int CasADi__MX__isOne(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isOne() );
}


// ================== Normal method: "isMinusOne" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isMinusOne"
// cWrapperName: "CasADi__MX__isMinusOne"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isMinusOne(CasADi::MX* obj)"
// call: "obj->isMinusOne()"
extern "C"
    int CasADi__MX__isMinusOne(CasADi::MX* obj);
int CasADi__MX__isMinusOne(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMinusOne() );
}


// ================== Normal method: "isTranspose" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isTranspose"
// cWrapperName: "CasADi__MX__isTranspose"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isTranspose(CasADi::MX* obj)"
// call: "obj->isTranspose()"
extern "C"
    int CasADi__MX__isTranspose(CasADi::MX* obj);
int CasADi__MX__isTranspose(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTranspose() );
}


// ================== Normal method: "isRegular" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isRegular"
// cWrapperName: "CasADi__MX__isRegular"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isRegular(CasADi::MX* obj)"
// call: "obj->isRegular()"
extern "C"
    int CasADi__MX__isRegular(CasADi::MX* obj);
int CasADi__MX__isRegular(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isRegular() );
}


// ================== Normal method: "getFunction" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getFunction"
// cWrapperName: "CasADi__MX__getFunction"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__MX__getFunction(CasADi::MX* obj)"
// call: "obj->getFunction()"
extern "C"
    CasADi::Function* CasADi__MX__getFunction(CasADi::MX* obj);
CasADi::Function* CasADi__MX__getFunction(CasADi::MX* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getFunction() );
}


// ================== Normal method: "isBinary" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isBinary"
// cWrapperName: "CasADi__MX__isBinary"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isBinary(CasADi::MX* obj)"
// call: "obj->isBinary()"
extern "C"
    int CasADi__MX__isBinary(CasADi::MX* obj);
int CasADi__MX__isBinary(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isBinary() );
}


// ================== Normal method: "isUnary" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isUnary"
// cWrapperName: "CasADi__MX__isUnary"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isUnary(CasADi::MX* obj)"
// call: "obj->isUnary()"
extern "C"
    int CasADi__MX__isUnary(CasADi::MX* obj);
int CasADi__MX__isUnary(CasADi::MX* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isUnary() );
}


// ================== Normal method: "getOp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getOp"
// cWrapperName: "CasADi__MX__getOp"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getOp(CasADi::MX* obj)"
// call: "obj->getOp()"
extern "C"
    int CasADi__MX__getOp(CasADi::MX* obj);
int CasADi__MX__getOp(CasADi::MX* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getOp() );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isEqual"
// cWrapperName: "CasADi__MX__isEqual"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1)"
// call: "obj->isEqual(x0_, x1_)"
extern "C"
    int CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1);
int CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_, x1_) );
}


// ================== Normal method: "isEqual'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isEqual'"
// cWrapperName: "CasADi__MX__isEqual_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    int CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0);
int CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_) );
}


// ================== Normal method: "__hash__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__hash__"
// cWrapperName: "CasADi__MX____hash__"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long CasADi__MX____hash__(CasADi::MX* obj)"
// call: "obj->__hash__()"
extern "C"
    long CasADi__MX____hash__(CasADi::MX* obj);
long CasADi__MX____hash__(CasADi::MX* obj){

    return WrapReturn< long, long >::wrapReturn( obj->__hash__() );
}


// ================== Normal method: "getTemp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getTemp"
// cWrapperName: "CasADi__MX__getTemp"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getTemp(CasADi::MX* obj)"
// call: "obj->getTemp()"
extern "C"
    int CasADi__MX__getTemp(CasADi::MX* obj);
int CasADi__MX__getTemp(CasADi::MX* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getTemp() );
}


// ================== Normal method: "setTemp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setTemp"
// cWrapperName: "CasADi__MX__setTemp"
// protoArgs: "(CasADi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setTemp(CasADi::MX* obj, int x0)"
// call: "obj->setTemp(x0_)"
extern "C"
    void CasADi__MX__setTemp(CasADi::MX* obj, int x0);
void CasADi__MX__setTemp(CasADi::MX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setTemp(x0_);
}


// ================== Static method: "binary" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::binary"
// cWrapperName: "CasADi__MX__binary"
// protoArgs: "(int x0, CasADi::MX* x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__binary(int x0, CasADi::MX* x1, CasADi::MX* x2)"
// call: "CasADi::MX::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MX__binary(int x0, CasADi::MX* x1, CasADi::MX* x2);
CasADi::MX* CasADi__MX__binary(int x0, CasADi::MX* x1, CasADi::MX* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::binary(x0_, x1_, x2_) );
}


// ================== Static method: "unary" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::unary"
// cWrapperName: "CasADi__MX__unary"
// protoArgs: "(int x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__unary(int x0, CasADi::MX* x1)"
// call: "CasADi::MX::unary(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__unary(int x0, CasADi::MX* x1);
CasADi::MX* CasADi__MX__unary(int x0, CasADi::MX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::unary(x0_, x1_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inf"
// cWrapperName: "CasADi__MX__inf"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__inf(CasADi::Sparsity* x0)"
// call: "CasADi::MX::inf(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__inf(CasADi::Sparsity* x0);
CasADi::MX* CasADi__MX__inf(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::inf(x0_) );
}


// ================== Static method: "inf'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inf'"
// cWrapperName: "CasADi__MX__inf_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__inf_TIC(int x0, int x1)"
// call: "CasADi::MX::inf(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__inf_TIC(int x0, int x1);
CasADi::MX* CasADi__MX__inf_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::inf(x0_, x1_) );
}


// ================== Static method: "inf''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inf''"
// cWrapperName: "CasADi__MX__inf_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__inf_TIC_TIC(int x0)"
// call: "CasADi::MX::inf(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__inf_TIC_TIC(int x0);
CasADi::MX* CasADi__MX__inf_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::inf(x0_) );
}


// ================== Static method: "inf'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inf'''"
// cWrapperName: "CasADi__MX__inf_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__inf_TIC_TIC_TIC()"
// call: "CasADi::MX::inf()"
extern "C"
    CasADi::MX* CasADi__MX__inf_TIC_TIC_TIC();
CasADi::MX* CasADi__MX__inf_TIC_TIC_TIC(){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nan"
// cWrapperName: "CasADi__MX__nan"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__nan(CasADi::Sparsity* x0)"
// call: "CasADi::MX::nan(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__nan(CasADi::Sparsity* x0);
CasADi::MX* CasADi__MX__nan(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::nan(x0_) );
}


// ================== Static method: "nan'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nan'"
// cWrapperName: "CasADi__MX__nan_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__nan_TIC(int x0, int x1)"
// call: "CasADi::MX::nan(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__nan_TIC(int x0, int x1);
CasADi::MX* CasADi__MX__nan_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::nan(x0_, x1_) );
}


// ================== Static method: "nan''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nan''"
// cWrapperName: "CasADi__MX__nan_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__nan_TIC_TIC(int x0)"
// call: "CasADi::MX::nan(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__nan_TIC_TIC(int x0);
CasADi::MX* CasADi__MX__nan_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::nan(x0_) );
}


// ================== Static method: "nan'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nan'''"
// cWrapperName: "CasADi__MX__nan_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__nan_TIC_TIC_TIC()"
// call: "CasADi::MX::nan()"
extern "C"
    CasADi::MX* CasADi__MX__nan_TIC_TIC_TIC();
CasADi::MX* CasADi__MX__nan_TIC_TIC_TIC(){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::repmat"
// cWrapperName: "CasADi__MX__repmat"
// protoArgs: "(CasADi::MX* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, CasADi::Sparsity* x1)"
// call: "CasADi::MX::repmat(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, CasADi::Sparsity* x1);
CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, CasADi::Sparsity* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::repmat(x0_, x1_) );
}


// ================== Static method: "repmat'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::repmat'"
// cWrapperName: "CasADi__MX__repmat_TIC"
// protoArgs: "(CasADi::MX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1, int x2)"
// call: "CasADi::MX::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1, int x2);
CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::repmat(x0_, x1_, x2_) );
}


// ================== Static method: "repmat''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::repmat''"
// cWrapperName: "CasADi__MX__repmat_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__repmat_TIC_TIC(CasADi::MX* x0, int x1)"
// call: "CasADi::MX::repmat(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__repmat_TIC_TIC(CasADi::MX* x0, int x1);
CasADi::MX* CasADi__MX__repmat_TIC_TIC(CasADi::MX* x0, int x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::repmat(x0_, x1_) );
}


// ================== Static method: "eye" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::eye"
// cWrapperName: "CasADi__MX__eye"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__eye(int x0)"
// call: "CasADi::MX::eye(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__eye(int x0);
CasADi::MX* CasADi__MX__eye(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX::eye(x0_) );
}


// ================== Normal method: "setSub" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub"
// cWrapperName: "CasADi__MX__setSub"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setSub(CasADi::MX* obj, CasADi::MX* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub(CasADi::MX* obj, CasADi::MX* x0, int x1, int x2);
void CasADi__MX__setSub(CasADi::MX* obj, CasADi::MX* x0, int x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub'"
// cWrapperName: "CasADi__MX__setSub_TIC"
// protoArgs: "(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_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, int x2);
void CasADi__MX__setSub_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,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_);
}


// ================== Normal method: "setSub''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC"
// protoArgs: "(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_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, int x1, std::vector< int >* x2);
void CasADi__MX__setSub_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, int x1, std::vector< int >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,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_);
}


// ================== Normal method: "setSub'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub'''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__MX__setSub_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,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_);
}


// ================== Normal method: "setSub''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub''''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setSub_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1)"
// call: "obj->setSub(x0_, x1_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1);
void CasADi__MX__setSub_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->setSub(x0_, x1_);
}


// ================== Normal method: "setSub'''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub'''''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2);
void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub''''''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub'''''''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Slice* x1, CasADi::Slice* x2);
void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Slice* x1, CasADi::Slice* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub''''''''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSub'''''''''"
// cWrapperName: "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1, int x2);
void CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "getNZ" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNZ"
// cWrapperName: "CasADi__MX__getNZ"
// protoArgs: "(CasADi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getNZ(CasADi::MX* obj, int x0)"
// call: "obj->getNZ(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__getNZ(CasADi::MX* obj, int x0);
CasADi::MX* CasADi__MX__getNZ(CasADi::MX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getNZ(x0_) );
}


// ================== Normal method: "getNZ'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNZ'"
// cWrapperName: "CasADi__MX__getNZ_TIC"
// protoArgs: "(CasADi::MX* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector< int >* x0)"
// call: "obj->getNZ(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector< int >* x0);
CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getNZ(x0_) );
}


// ================== Normal method: "getNZ''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNZ''"
// cWrapperName: "CasADi__MX__getNZ_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Slice* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getNZ_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0)"
// call: "obj->getNZ(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__getNZ_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0);
CasADi::MX* CasADi__MX__getNZ_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getNZ(x0_) );
}


// ================== Normal method: "getNZ'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNZ'''"
// cWrapperName: "CasADi__MX__getNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__getNZ_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0)"
// call: "obj->getNZ(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__getNZ_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0);
CasADi::MX* CasADi__MX__getNZ_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->getNZ(x0_) );
}


// ================== Normal method: "setNZ" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setNZ"
// cWrapperName: "CasADi__MX__setNZ"
// protoArgs: "(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setNZ(CasADi::MX* obj, int x0, CasADi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__MX__setNZ(CasADi::MX* obj, int x0, CasADi::MX* x1);
void CasADi__MX__setNZ(CasADi::MX* obj, int x0, CasADi::MX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setNZ'"
// cWrapperName: "CasADi__MX__setNZ_TIC"
// protoArgs: "(CasADi::MX* obj, std::vector< int >* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setNZ_TIC(CasADi::MX* obj, std::vector< int >* x0, CasADi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__MX__setNZ_TIC(CasADi::MX* obj, std::vector< int >* x0, CasADi::MX* x1);
void CasADi__MX__setNZ_TIC(CasADi::MX* obj, std::vector< int >* x0, CasADi::MX* x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setNZ''"
// cWrapperName: "CasADi__MX__setNZ_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setNZ_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__MX__setNZ_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1);
void CasADi__MX__setNZ_TIC_TIC(CasADi::MX* obj, CasADi::Slice* x0, CasADi::MX* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setNZ'''"
// cWrapperName: "CasADi__MX__setNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setNZ_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__MX__setNZ_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1);
void CasADi__MX__setNZ_TIC_TIC_TIC(CasADi::MX* obj, CasADi::Matrix< int >* x0, CasADi::MX* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "append" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::append"
// cWrapperName: "CasADi__MX__append"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__append(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->append(x0_)"
extern "C"
    void CasADi__MX__append(CasADi::MX* obj, CasADi::MX* x0);
void CasADi__MX__append(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    obj->append(x0_);
}


// ================== Normal method: "appendColumns" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::appendColumns"
// cWrapperName: "CasADi__MX__appendColumns"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__appendColumns(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->appendColumns(x0_)"
extern "C"
    void CasADi__MX__appendColumns(CasADi::MX* obj, CasADi::MX* x0);
void CasADi__MX__appendColumns(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    obj->appendColumns(x0_);
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__add__"
// cWrapperName: "CasADi__MX____add__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____add__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____add__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____add__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__sub__"
// cWrapperName: "CasADi__MX____sub__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____sub__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____sub__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____sub__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__mul__"
// cWrapperName: "CasADi__MX____mul__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____mul__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____mul__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____mul__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__div__"
// cWrapperName: "CasADi__MX____div__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____div__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____div__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____div__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__lt__"
// cWrapperName: "CasADi__MX____lt__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____lt__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____lt__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____lt__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__le__"
// cWrapperName: "CasADi__MX____le__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____le__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____le__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____le__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__eq__"
// cWrapperName: "CasADi__MX____eq__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____eq__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____eq__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____eq__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__ne__"
// cWrapperName: "CasADi__MX____ne__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____ne__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____ne__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____ne__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__truediv__"
// cWrapperName: "CasADi__MX____truediv__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____truediv__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____truediv__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____truediv__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__pow__"
// cWrapperName: "CasADi__MX____pow__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____pow__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____pow__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____pow__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__constpow__"
// cWrapperName: "CasADi__MX____constpow__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____constpow__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____constpow__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____constpow__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__mrdivide__"
// cWrapperName: "CasADi__MX____mrdivide__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____mrdivide__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____mrdivide__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____mrdivide__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__mpower__"
// cWrapperName: "CasADi__MX____mpower__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____mpower__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____mpower__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____mpower__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__mpower__(x0_) );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::mul"
// cWrapperName: "CasADi__MX__mul"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1);
CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->mul(x0_, x1_) );
}


// ================== Normal method: "mul'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::mul'"
// cWrapperName: "CasADi__MX__mul_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__mul_TIC(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__mul_TIC(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__mul_TIC(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->mul(x0_) );
}


// ================== Normal method: "mul_full" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::mul_full"
// cWrapperName: "CasADi__MX__mul_full"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1);
CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::Sparsity* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->mul_full(x0_, x1_) );
}


// ================== Normal method: "mul_full'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::mul_full'"
// cWrapperName: "CasADi__MX__mul_full_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__mul_full_TIC(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->mul_full(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__mul_full_TIC(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__mul_full_TIC(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->mul_full(x0_) );
}


// ================== Normal method: "inner_prod" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inner_prod"
// cWrapperName: "CasADi__MX__inner_prod"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__inner_prod(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->inner_prod(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__inner_prod(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__inner_prod(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->inner_prod(x0_) );
}


// ================== Normal method: "outer_prod" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::outer_prod"
// cWrapperName: "CasADi__MX__outer_prod"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__outer_prod(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->outer_prod(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__outer_prod(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__outer_prod(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->outer_prod(x0_) );
}


// ================== Normal method: "constpow" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::constpow"
// cWrapperName: "CasADi__MX__constpow"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__constpow(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->constpow(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__constpow(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__constpow(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->constpow(x0_) );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::fmin"
// cWrapperName: "CasADi__MX__fmin"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__fmin(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__fmin(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__fmin(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::fmax"
// cWrapperName: "CasADi__MX__fmax"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__fmax(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__fmax(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__fmax(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->fmax(x0_) );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::printme"
// cWrapperName: "CasADi__MX__printme"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__printme(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__printme(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__printme(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->printme(x0_) );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arctan2"
// cWrapperName: "CasADi__MX__arctan2"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arctan2(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__arctan2(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__arctan2(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arctan2(x0_) );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::logic_and"
// cWrapperName: "CasADi__MX__logic_and"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__logic_and(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__logic_and(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__logic_and(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::logic_or"
// cWrapperName: "CasADi__MX__logic_or"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__logic_or(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__logic_or(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__logic_or(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::if_else_zero"
// cWrapperName: "CasADi__MX__if_else_zero"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__if_else_zero(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__if_else_zero(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__if_else_zero(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->if_else_zero(x0_) );
}


// ================== Normal method: "__copysign__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__copysign__"
// cWrapperName: "CasADi__MX____copysign__"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX____copysign__(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->__copysign__(x0_)"
extern "C"
    CasADi::MX* CasADi__MX____copysign__(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX____copysign__(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->__copysign__(x0_) );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::exp"
// cWrapperName: "CasADi__MX__exp"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__exp(CasADi::MX* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::MX* CasADi__MX__exp(CasADi::MX* obj);
CasADi::MX* CasADi__MX__exp(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::log"
// cWrapperName: "CasADi__MX__log"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__log(CasADi::MX* obj)"
// call: "obj->log()"
extern "C"
    CasADi::MX* CasADi__MX__log(CasADi::MX* obj);
CasADi::MX* CasADi__MX__log(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->log() );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::log10"
// cWrapperName: "CasADi__MX__log10"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__log10(CasADi::MX* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::MX* CasADi__MX__log10(CasADi::MX* obj);
CasADi::MX* CasADi__MX__log10(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->log10() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sqrt"
// cWrapperName: "CasADi__MX__sqrt"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__sqrt(CasADi::MX* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::MX* CasADi__MX__sqrt(CasADi::MX* obj);
CasADi::MX* CasADi__MX__sqrt(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->sqrt() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sin"
// cWrapperName: "CasADi__MX__sin"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__sin(CasADi::MX* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::MX* CasADi__MX__sin(CasADi::MX* obj);
CasADi::MX* CasADi__MX__sin(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::cos"
// cWrapperName: "CasADi__MX__cos"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__cos(CasADi::MX* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::MX* CasADi__MX__cos(CasADi::MX* obj);
CasADi::MX* CasADi__MX__cos(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::tan"
// cWrapperName: "CasADi__MX__tan"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__tan(CasADi::MX* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::MX* CasADi__MX__tan(CasADi::MX* obj);
CasADi::MX* CasADi__MX__tan(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arcsin"
// cWrapperName: "CasADi__MX__arcsin"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arcsin(CasADi::MX* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::MX* CasADi__MX__arcsin(CasADi::MX* obj);
CasADi::MX* CasADi__MX__arcsin(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arccos"
// cWrapperName: "CasADi__MX__arccos"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arccos(CasADi::MX* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::MX* CasADi__MX__arccos(CasADi::MX* obj);
CasADi::MX* CasADi__MX__arccos(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arctan"
// cWrapperName: "CasADi__MX__arctan"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arctan(CasADi::MX* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::MX* CasADi__MX__arctan(CasADi::MX* obj);
CasADi::MX* CasADi__MX__arctan(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arctan() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::floor"
// cWrapperName: "CasADi__MX__floor"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__floor(CasADi::MX* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::MX* CasADi__MX__floor(CasADi::MX* obj);
CasADi::MX* CasADi__MX__floor(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::ceil"
// cWrapperName: "CasADi__MX__ceil"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__ceil(CasADi::MX* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::MX* CasADi__MX__ceil(CasADi::MX* obj);
CasADi::MX* CasADi__MX__ceil(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->ceil() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::fabs"
// cWrapperName: "CasADi__MX__fabs"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__fabs(CasADi::MX* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::MX* CasADi__MX__fabs(CasADi::MX* obj);
CasADi::MX* CasADi__MX__fabs(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->fabs() );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sign"
// cWrapperName: "CasADi__MX__sign"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__sign(CasADi::MX* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::MX* CasADi__MX__sign(CasADi::MX* obj);
CasADi::MX* CasADi__MX__sign(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->sign() );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::erfinv"
// cWrapperName: "CasADi__MX__erfinv"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__erfinv(CasADi::MX* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::MX* CasADi__MX__erfinv(CasADi::MX* obj);
CasADi::MX* CasADi__MX__erfinv(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->erfinv() );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::erf"
// cWrapperName: "CasADi__MX__erf"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__erf(CasADi::MX* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::MX* CasADi__MX__erf(CasADi::MX* obj);
CasADi::MX* CasADi__MX__erf(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->erf() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sinh"
// cWrapperName: "CasADi__MX__sinh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__sinh(CasADi::MX* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::MX* CasADi__MX__sinh(CasADi::MX* obj);
CasADi::MX* CasADi__MX__sinh(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::cosh"
// cWrapperName: "CasADi__MX__cosh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__cosh(CasADi::MX* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::MX* CasADi__MX__cosh(CasADi::MX* obj);
CasADi::MX* CasADi__MX__cosh(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::tanh"
// cWrapperName: "CasADi__MX__tanh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__tanh(CasADi::MX* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::MX* CasADi__MX__tanh(CasADi::MX* obj);
CasADi::MX* CasADi__MX__tanh(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arcsinh"
// cWrapperName: "CasADi__MX__arcsinh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arcsinh(CasADi::MX* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::MX* CasADi__MX__arcsinh(CasADi::MX* obj);
CasADi::MX* CasADi__MX__arcsinh(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arccosh"
// cWrapperName: "CasADi__MX__arccosh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arccosh(CasADi::MX* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::MX* CasADi__MX__arccosh(CasADi::MX* obj);
CasADi::MX* CasADi__MX__arccosh(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arctanh"
// cWrapperName: "CasADi__MX__arctanh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__arctanh(CasADi::MX* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::MX* CasADi__MX__arctanh(CasADi::MX* obj);
CasADi::MX* CasADi__MX__arctanh(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->arctanh() );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::logic_not"
// cWrapperName: "CasADi__MX__logic_not"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__logic_not(CasADi::MX* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::MX* CasADi__MX__logic_not(CasADi::MX* obj);
CasADi::MX* CasADi__MX__logic_not(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->logic_not() );
}


// ================== Normal method: "attachAssert" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::attachAssert"
// cWrapperName: "CasADi__MX__attachAssert"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__attachAssert(CasADi::MX* obj, CasADi::MX* x0, std::string* x1)"
// call: "obj->attachAssert(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__attachAssert(CasADi::MX* obj, CasADi::MX* x0, std::string* x1);
CasADi::MX* CasADi__MX__attachAssert(CasADi::MX* obj, CasADi::MX* x0, std::string* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->attachAssert(x0_, x1_) );
}


// ================== Normal method: "attachAssert'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::attachAssert'"
// cWrapperName: "CasADi__MX__attachAssert_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__attachAssert_TIC(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->attachAssert(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__attachAssert_TIC(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__attachAssert_TIC(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->attachAssert(x0_) );
}


// ================== Normal method: "setSparse" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSparse"
// cWrapperName: "CasADi__MX__setSparse"
// protoArgs: "(CasADi::MX* obj, CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::Sparsity* x0, int x1);
CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->setSparse(x0_, x1_) );
}


// ================== Normal method: "setSparse'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSparse'"
// cWrapperName: "CasADi__MX__setSparse_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::Sparsity* x0);
CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->setSparse(x0_) );
}


// ================== Normal method: "densify" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::densify"
// cWrapperName: "CasADi__MX__densify"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__densify(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->densify(x0_)"
extern "C"
    void CasADi__MX__densify(CasADi::MX* obj, CasADi::MX* x0);
void CasADi__MX__densify(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    obj->densify(x0_);
}


// ================== Normal method: "densify'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::densify'"
// cWrapperName: "CasADi__MX__densify_TIC"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__densify_TIC(CasADi::MX* obj)"
// call: "obj->densify()"
extern "C"
    void CasADi__MX__densify_TIC(CasADi::MX* obj);
void CasADi__MX__densify_TIC(CasADi::MX* obj){

    obj->densify();
}


// ================== Normal method: "lift" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::lift"
// cWrapperName: "CasADi__MX__lift"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__lift(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->lift(x0_)"
extern "C"
    void CasADi__MX__lift(CasADi::MX* obj, CasADi::MX* x0);
void CasADi__MX__lift(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    obj->lift(x0_);
}


// ================== Normal method: "addToSum" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::addToSum"
// cWrapperName: "CasADi__MX__addToSum"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__addToSum(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->addToSum(x0_)"
extern "C"
    void CasADi__MX__addToSum(CasADi::MX* obj, CasADi::MX* x0);
void CasADi__MX__addToSum(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    obj->addToSum(x0_);
}


// ================== Normal method: "trans" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::trans"
// cWrapperName: "CasADi__MX__trans"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__trans(CasADi::MX* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::MX* CasADi__MX__trans(CasADi::MX* obj);
CasADi::MX* CasADi__MX__trans(CasADi::MX* obj){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->trans() );
}


// ================== Normal method: "mapping" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::mapping"
// cWrapperName: "CasADi__MX__mapping"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__MX__mapping(CasADi::MX* obj)"
// call: "obj->mapping()"
extern "C"
    CasADi::Matrix< int >* CasADi__MX__mapping(CasADi::MX* obj);
CasADi::Matrix< int >* CasADi__MX__mapping(CasADi::MX* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->mapping() );
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setMaxNumCallsInPrint"
// cWrapperName: "CasADi__MX__setMaxNumCallsInPrint"
// protoArgs: "(long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setMaxNumCallsInPrint(long x0)"
// call: "CasADi::MX::setMaxNumCallsInPrint(x0_)"
extern "C"
    void CasADi__MX__setMaxNumCallsInPrint(long x0);
void CasADi__MX__setMaxNumCallsInPrint(long x0){
    long x0_ = Marshaling<long,long>::marshal(x0);

    CasADi::MX::setMaxNumCallsInPrint(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setMaxNumCallsInPrint'"
// cWrapperName: "CasADi__MX__setMaxNumCallsInPrint_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setMaxNumCallsInPrint_TIC()"
// call: "CasADi::MX::setMaxNumCallsInPrint()"
extern "C"
    void CasADi__MX__setMaxNumCallsInPrint_TIC();
void CasADi__MX__setMaxNumCallsInPrint_TIC(){

    CasADi::MX::setMaxNumCallsInPrint();
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getMaxNumCallsInPrint"
// cWrapperName: "CasADi__MX__getMaxNumCallsInPrint"
// protoArgs: "()"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long CasADi__MX__getMaxNumCallsInPrint()"
// call: "CasADi::MX::getMaxNumCallsInPrint()"
extern "C"
    long CasADi__MX__getMaxNumCallsInPrint();
long CasADi__MX__getMaxNumCallsInPrint(){

    return WrapReturn< long, long >::wrapReturn( CasADi::MX::getMaxNumCallsInPrint() );
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setEqualityCheckingDepth"
// cWrapperName: "CasADi__MX__setEqualityCheckingDepth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setEqualityCheckingDepth(int x0)"
// call: "CasADi::MX::setEqualityCheckingDepth(x0_)"
extern "C"
    void CasADi__MX__setEqualityCheckingDepth(int x0);
void CasADi__MX__setEqualityCheckingDepth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::MX::setEqualityCheckingDepth(x0_);
}


// ================== Static method: "setEqualityCheckingDepth'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setEqualityCheckingDepth'"
// cWrapperName: "CasADi__MX__setEqualityCheckingDepth_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__MX__setEqualityCheckingDepth_TIC()"
// call: "CasADi::MX::setEqualityCheckingDepth()"
extern "C"
    void CasADi__MX__setEqualityCheckingDepth_TIC();
void CasADi__MX__setEqualityCheckingDepth_TIC(){

    CasADi::MX::setEqualityCheckingDepth();
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getEqualityCheckingDepth"
// cWrapperName: "CasADi__MX__getEqualityCheckingDepth"
// protoArgs: "()"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getEqualityCheckingDepth()"
// call: "CasADi::MX::getEqualityCheckingDepth()"
extern "C"
    int CasADi__MX__getEqualityCheckingDepth();
int CasADi__MX__getEqualityCheckingDepth(){

    return WrapReturn< int, int >::wrapReturn( CasADi::MX::getEqualityCheckingDepth() );
}


// ================== Constructor method: "MX" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX()"
// call: "CasADi::MX()"
extern "C"
    CasADi::MX* CasADi__MX__MX();
CasADi::MX* CasADi__MX__MX(){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX() );
}


// ================== Constructor method: "MX'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::MX(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC(CasADi::Sparsity* x0, int x1);
CasADi::MX* CasADi__MX__MX_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_, x1_) );
}


// ================== Constructor method: "MX''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::MX(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC(CasADi::Sparsity* x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC(CasADi::Sparsity* x0, double x1)"
// call: "CasADi::MX(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC(CasADi::Sparsity* x0, double x1);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC(CasADi::Sparsity* x0, double x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_, x1_) );
}


// ================== Constructor method: "MX''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::MX* x1)"
// call: "CasADi::MX(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::MX* x1);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::MX* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_, x1_) );
}


// ================== Constructor method: "MX'''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(double x0)"
// call: "CasADi::MX(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(double x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::MX(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX'''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0)"
// call: "CasADi::MX(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::MX(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::MX(x0_) );
}


// ================== delete CasadiClass QCQPStructure===============
// classType: CasadiClass QCQPStructure
extern "C"
    void delete_CasADi__QCQPStructIOSchemeVector_CasADi__Sparsity_(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* obj);
void delete_CasADi__QCQPStructIOSchemeVector_CasADi__Sparsity_(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* obj){
    delete obj;
}

// ================== Constructor method: "QCQPStructure" ===============
// class: "CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >"
// cppName: "CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >"
// cWrapperName: "CasADi__QCQPStructIOSchemeVector_CasADi__Sparsity___QCQPStructure"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QCQPStructure
// cWrapperRetType: "CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >*"
// proto: "CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* CasADi__QCQPStructIOSchemeVector_CasADi__Sparsity___QCQPStructure(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >(x0_)"
extern "C"
    CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* CasADi__QCQPStructIOSchemeVector_CasADi__Sparsity___QCQPStructure(std::vector< CasADi::Sparsity* >* x0);
CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* CasADi__QCQPStructIOSchemeVector_CasADi__Sparsity___QCQPStructure(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >*, CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity > >::wrapReturn( CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >(x0_) );
}


// ================== delete CasadiClass DpleSolver===============
// classType: CasadiClass DpleSolver
extern "C"
    void delete_CasADi__DpleSolver(CasADi::DpleSolver* obj);
void delete_CasADi__DpleSolver(CasADi::DpleSolver* obj){
    delete obj;
}

// ================== Normal method: "clone" ===============
// class: "CasADi::DpleSolver"
// cppName: "CasADi::DpleSolver::clone"
// cWrapperName: "CasADi__DpleSolver__clone"
// protoArgs: "(CasADi::DpleSolver* obj)"
// args: "()"
// rettype: CasadiClass DpleSolver
// cWrapperRetType: "CasADi::DpleSolver*"
// proto: "CasADi::DpleSolver* CasADi__DpleSolver__clone(CasADi::DpleSolver* obj)"
// call: "obj->clone()"
extern "C"
    CasADi::DpleSolver* CasADi__DpleSolver__clone(CasADi::DpleSolver* obj);
CasADi::DpleSolver* CasADi__DpleSolver__clone(CasADi::DpleSolver* obj){

    return WrapReturn< CasADi::DpleSolver*, CasADi::DpleSolver >::wrapReturn( obj->clone() );
}


// ================== Normal method: "printStats'" ===============
// class: "CasADi::DpleSolver"
// cppName: "CasADi::DpleSolver::printStats'"
// cWrapperName: "CasADi__DpleSolver__printStats_TIC"
// protoArgs: "(CasADi::DpleSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DpleSolver__printStats_TIC(CasADi::DpleSolver* obj)"
// call: "obj->printStats()"
extern "C"
    void CasADi__DpleSolver__printStats_TIC(CasADi::DpleSolver* obj);
void CasADi__DpleSolver__printStats_TIC(CasADi::DpleSolver* obj){

    obj->printStats();
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::DpleSolver"
// cppName: "CasADi::DpleSolver::checkNode"
// cWrapperName: "CasADi__DpleSolver__checkNode"
// protoArgs: "(CasADi::DpleSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__DpleSolver__checkNode(CasADi::DpleSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__DpleSolver__checkNode(CasADi::DpleSolver* obj);
int CasADi__DpleSolver__checkNode(CasADi::DpleSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "DpleSolver" ===============
// class: "CasADi::DpleSolver"
// cppName: "CasADi::DpleSolver"
// cWrapperName: "CasADi__DpleSolver__DpleSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DpleSolver
// cWrapperRetType: "CasADi::DpleSolver*"
// proto: "CasADi::DpleSolver* CasADi__DpleSolver__DpleSolver()"
// call: "CasADi::DpleSolver()"
extern "C"
    CasADi::DpleSolver* CasADi__DpleSolver__DpleSolver();
CasADi::DpleSolver* CasADi__DpleSolver__DpleSolver(){

    return WrapReturn< CasADi::DpleSolver*, CasADi::DpleSolver >::wrapReturn( CasADi::DpleSolver() );
}


// ================== delete CasadiClass SDQPSolver===============
// classType: CasadiClass SDQPSolver
extern "C"
    void delete_CasADi__SDQPSolver(CasADi::SDQPSolver* obj);
void delete_CasADi__SDQPSolver(CasADi::SDQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SDQPSolver"
// cppName: "CasADi::SDQPSolver::checkNode"
// cWrapperName: "CasADi__SDQPSolver__checkNode"
// protoArgs: "(CasADi::SDQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SDQPSolver__checkNode(CasADi::SDQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SDQPSolver__checkNode(CasADi::SDQPSolver* obj);
int CasADi__SDQPSolver__checkNode(CasADi::SDQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "setSOCQPOptions" ===============
// class: "CasADi::SDQPSolver"
// cppName: "CasADi::SDQPSolver::setSOCQPOptions"
// cWrapperName: "CasADi__SDQPSolver__setSOCQPOptions"
// protoArgs: "(CasADi::SDQPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SDQPSolver__setSOCQPOptions(CasADi::SDQPSolver* obj)"
// call: "obj->setSOCQPOptions()"
extern "C"
    void CasADi__SDQPSolver__setSOCQPOptions(CasADi::SDQPSolver* obj);
void CasADi__SDQPSolver__setSOCQPOptions(CasADi::SDQPSolver* obj){

    obj->setSOCQPOptions();
}


// ================== Constructor method: "SDQPSolver" ===============
// class: "CasADi::SDQPSolver"
// cppName: "CasADi::SDQPSolver"
// cWrapperName: "CasADi__SDQPSolver__SDQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SDQPSolver
// cWrapperRetType: "CasADi::SDQPSolver*"
// proto: "CasADi::SDQPSolver* CasADi__SDQPSolver__SDQPSolver()"
// call: "CasADi::SDQPSolver()"
extern "C"
    CasADi::SDQPSolver* CasADi__SDQPSolver__SDQPSolver();
CasADi::SDQPSolver* CasADi__SDQPSolver__SDQPSolver(){

    return WrapReturn< CasADi::SDQPSolver*, CasADi::SDQPSolver >::wrapReturn( CasADi::SDQPSolver() );
}


// ================== delete CasadiClass QPLPSolver===============
// classType: CasadiClass QPLPSolver
extern "C"
    void delete_CasADi__QPLPSolver(CasADi::QPLPSolver* obj);
void delete_CasADi__QPLPSolver(CasADi::QPLPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::QPLPSolver"
// cppName: "CasADi::QPLPSolver::checkNode"
// cWrapperName: "CasADi__QPLPSolver__checkNode"
// protoArgs: "(CasADi::QPLPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__QPLPSolver__checkNode(CasADi::QPLPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__QPLPSolver__checkNode(CasADi::QPLPSolver* obj);
int CasADi__QPLPSolver__checkNode(CasADi::QPLPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::QPLPSolver"
// cppName: "CasADi::QPLPSolver::creator"
// cWrapperName: "CasADi__QPLPSolver__creator"
// protoArgs: "(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass LPSolver
// cWrapperRetType: "CasADi::LPSolver*"
// proto: "CasADi::LPSolver* CasADi__QPLPSolver__creator(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::QPLPSolver::creator(x0_)"
extern "C"
    CasADi::LPSolver* CasADi__QPLPSolver__creator(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::LPSolver* CasADi__QPLPSolver__creator(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::LPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::LPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::LPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::LPSolver*, CasADi::LPSolver >::wrapReturn( CasADi::QPLPSolver::creator(x0_) );
}


// ================== Normal method: "getSolver" ===============
// class: "CasADi::QPLPSolver"
// cppName: "CasADi::QPLPSolver::getSolver"
// cWrapperName: "CasADi__QPLPSolver__getSolver"
// protoArgs: "(CasADi::QPLPSolver* obj)"
// args: "()"
// rettype: CasadiClass QPSolver
// cWrapperRetType: "CasADi::QPSolver*"
// proto: "CasADi::QPSolver* CasADi__QPLPSolver__getSolver(CasADi::QPLPSolver* obj)"
// call: "obj->getSolver()"
extern "C"
    CasADi::QPSolver* CasADi__QPLPSolver__getSolver(CasADi::QPLPSolver* obj);
CasADi::QPSolver* CasADi__QPLPSolver__getSolver(CasADi::QPLPSolver* obj){

    return WrapReturn< CasADi::QPSolver*, CasADi::QPSolver >::wrapReturn( obj->getSolver() );
}


// ================== Constructor method: "QPLPSolver" ===============
// class: "CasADi::QPLPSolver"
// cppName: "CasADi::QPLPSolver"
// cWrapperName: "CasADi__QPLPSolver__QPLPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass QPLPSolver
// cWrapperRetType: "CasADi::QPLPSolver*"
// proto: "CasADi::QPLPSolver* CasADi__QPLPSolver__QPLPSolver()"
// call: "CasADi::QPLPSolver()"
extern "C"
    CasADi::QPLPSolver* CasADi__QPLPSolver__QPLPSolver();
CasADi::QPLPSolver* CasADi__QPLPSolver__QPLPSolver(){

    return WrapReturn< CasADi::QPLPSolver*, CasADi::QPLPSolver >::wrapReturn( CasADi::QPLPSolver() );
}


// ================== Constructor method: "QPLPSolver'" ===============
// class: "CasADi::QPLPSolver"
// cppName: "CasADi::QPLPSolver"
// cWrapperName: "CasADi__QPLPSolver__QPLPSolver_TIC"
// protoArgs: "(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QPLPSolver
// cWrapperRetType: "CasADi::QPLPSolver*"
// proto: "CasADi::QPLPSolver* CasADi__QPLPSolver__QPLPSolver_TIC(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::QPLPSolver(x0_)"
extern "C"
    CasADi::QPLPSolver* CasADi__QPLPSolver__QPLPSolver_TIC(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::QPLPSolver* CasADi__QPLPSolver__QPLPSolver_TIC(CasADi::LPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::LPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::LPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::LPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::QPLPSolver*, CasADi::QPLPSolver >::wrapReturn( CasADi::QPLPSolver(x0_) );
}


// ================== delete CasadiClass SDPSDQPSolver===============
// classType: CasadiClass SDPSDQPSolver
extern "C"
    void delete_CasADi__SDPSDQPSolver(CasADi::SDPSDQPSolver* obj);
void delete_CasADi__SDPSDQPSolver(CasADi::SDPSDQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SDPSDQPSolver"
// cppName: "CasADi::SDPSDQPSolver::checkNode"
// cWrapperName: "CasADi__SDPSDQPSolver__checkNode"
// protoArgs: "(CasADi::SDPSDQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SDPSDQPSolver__checkNode(CasADi::SDPSDQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SDPSDQPSolver__checkNode(CasADi::SDPSDQPSolver* obj);
int CasADi__SDPSDQPSolver__checkNode(CasADi::SDPSDQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SDPSDQPSolver"
// cppName: "CasADi::SDPSDQPSolver::creator"
// cWrapperName: "CasADi__SDPSDQPSolver__creator"
// protoArgs: "(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SDQPSolver
// cWrapperRetType: "CasADi::SDQPSolver*"
// proto: "CasADi::SDQPSolver* CasADi__SDPSDQPSolver__creator(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::SDPSDQPSolver::creator(x0_)"
extern "C"
    CasADi::SDQPSolver* CasADi__SDPSDQPSolver__creator(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::SDQPSolver* CasADi__SDPSDQPSolver__creator(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::SDQPSolver*, CasADi::SDQPSolver >::wrapReturn( CasADi::SDPSDQPSolver::creator(x0_) );
}


// ================== Normal method: "getSolver" ===============
// class: "CasADi::SDPSDQPSolver"
// cppName: "CasADi::SDPSDQPSolver::getSolver"
// cWrapperName: "CasADi__SDPSDQPSolver__getSolver"
// protoArgs: "(CasADi::SDPSDQPSolver* obj)"
// args: "()"
// rettype: CasadiClass SDPSolver
// cWrapperRetType: "CasADi::SDPSolver*"
// proto: "CasADi::SDPSolver* CasADi__SDPSDQPSolver__getSolver(CasADi::SDPSDQPSolver* obj)"
// call: "obj->getSolver()"
extern "C"
    CasADi::SDPSolver* CasADi__SDPSDQPSolver__getSolver(CasADi::SDPSDQPSolver* obj);
CasADi::SDPSolver* CasADi__SDPSDQPSolver__getSolver(CasADi::SDPSDQPSolver* obj){

    return WrapReturn< CasADi::SDPSolver*, CasADi::SDPSolver >::wrapReturn( obj->getSolver() );
}


// ================== Constructor method: "SDPSDQPSolver" ===============
// class: "CasADi::SDPSDQPSolver"
// cppName: "CasADi::SDPSDQPSolver"
// cWrapperName: "CasADi__SDPSDQPSolver__SDPSDQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SDPSDQPSolver
// cWrapperRetType: "CasADi::SDPSDQPSolver*"
// proto: "CasADi::SDPSDQPSolver* CasADi__SDPSDQPSolver__SDPSDQPSolver()"
// call: "CasADi::SDPSDQPSolver()"
extern "C"
    CasADi::SDPSDQPSolver* CasADi__SDPSDQPSolver__SDPSDQPSolver();
CasADi::SDPSDQPSolver* CasADi__SDPSDQPSolver__SDPSDQPSolver(){

    return WrapReturn< CasADi::SDPSDQPSolver*, CasADi::SDPSDQPSolver >::wrapReturn( CasADi::SDPSDQPSolver() );
}


// ================== Constructor method: "SDPSDQPSolver'" ===============
// class: "CasADi::SDPSDQPSolver"
// cppName: "CasADi::SDPSDQPSolver"
// cWrapperName: "CasADi__SDPSDQPSolver__SDPSDQPSolver_TIC"
// protoArgs: "(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SDPSDQPSolver
// cWrapperRetType: "CasADi::SDPSDQPSolver*"
// proto: "CasADi::SDPSDQPSolver* CasADi__SDPSDQPSolver__SDPSDQPSolver_TIC(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::SDPSDQPSolver(x0_)"
extern "C"
    CasADi::SDPSDQPSolver* CasADi__SDPSDQPSolver__SDPSDQPSolver_TIC(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::SDPSDQPSolver* CasADi__SDPSDQPSolver__SDPSDQPSolver_TIC(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::SDPSDQPSolver*, CasADi::SDPSDQPSolver >::wrapReturn( CasADi::SDPSDQPSolver(x0_) );
}




// ================== delete CasadiClass SDPSolver===============
// classType: CasadiClass SDPSolver
extern "C"
    void delete_CasADi__SDPSolver(CasADi::SDPSolver* obj);
void delete_CasADi__SDPSolver(CasADi::SDPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SDPSolver"
// cppName: "CasADi::SDPSolver::checkNode"
// cWrapperName: "CasADi__SDPSolver__checkNode"
// protoArgs: "(CasADi::SDPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SDPSolver__checkNode(CasADi::SDPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SDPSolver__checkNode(CasADi::SDPSolver* obj);
int CasADi__SDPSolver__checkNode(CasADi::SDPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "setSOCPOptions" ===============
// class: "CasADi::SDPSolver"
// cppName: "CasADi::SDPSolver::setSOCPOptions"
// cWrapperName: "CasADi__SDPSolver__setSOCPOptions"
// protoArgs: "(CasADi::SDPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SDPSolver__setSOCPOptions(CasADi::SDPSolver* obj)"
// call: "obj->setSOCPOptions()"
extern "C"
    void CasADi__SDPSolver__setSOCPOptions(CasADi::SDPSolver* obj);
void CasADi__SDPSolver__setSOCPOptions(CasADi::SDPSolver* obj){

    obj->setSOCPOptions();
}


// ================== Constructor method: "SDPSolver" ===============
// class: "CasADi::SDPSolver"
// cppName: "CasADi::SDPSolver"
// cWrapperName: "CasADi__SDPSolver__SDPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SDPSolver
// cWrapperRetType: "CasADi::SDPSolver*"
// proto: "CasADi::SDPSolver* CasADi__SDPSolver__SDPSolver()"
// call: "CasADi::SDPSolver()"
extern "C"
    CasADi::SDPSolver* CasADi__SDPSolver__SDPSolver();
CasADi::SDPSolver* CasADi__SDPSolver__SDPSolver(){

    return WrapReturn< CasADi::SDPSolver*, CasADi::SDPSolver >::wrapReturn( CasADi::SDPSolver() );
}


// ================== delete CasadiClass CasadiOptions===============
// classType: CasadiClass CasadiOptions
extern "C"
    void delete_CasADi__CasadiOptions(CasADi::CasadiOptions* obj);
void delete_CasADi__CasadiOptions(CasADi::CasadiOptions* obj){
    delete obj;
}

// ================== Static method: "setCatchErrorsPython" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setCatchErrorsPython"
// cWrapperName: "CasADi__CasadiOptions__setCatchErrorsPython"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setCatchErrorsPython(int x0)"
// call: "CasADi::CasadiOptions::setCatchErrorsPython(x0_)"
extern "C"
    void CasADi__CasadiOptions__setCatchErrorsPython(int x0);
void CasADi__CasadiOptions__setCatchErrorsPython(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::CasadiOptions::setCatchErrorsPython(x0_);
}


// ================== Static method: "getCatchErrorsPython" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::getCatchErrorsPython"
// cWrapperName: "CasADi__CasadiOptions__getCatchErrorsPython"
// protoArgs: "()"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CasadiOptions__getCatchErrorsPython()"
// call: "CasADi::CasadiOptions::getCatchErrorsPython()"
extern "C"
    int CasADi__CasadiOptions__getCatchErrorsPython();
int CasADi__CasadiOptions__getCatchErrorsPython(){

    return WrapReturn< int, bool >::wrapReturn( CasADi::CasadiOptions::getCatchErrorsPython() );
}


// ================== Static method: "setSimplificationOnTheFly" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setSimplificationOnTheFly"
// cWrapperName: "CasADi__CasadiOptions__setSimplificationOnTheFly"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setSimplificationOnTheFly(int x0)"
// call: "CasADi::CasadiOptions::setSimplificationOnTheFly(x0_)"
extern "C"
    void CasADi__CasadiOptions__setSimplificationOnTheFly(int x0);
void CasADi__CasadiOptions__setSimplificationOnTheFly(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::CasadiOptions::setSimplificationOnTheFly(x0_);
}


// ================== Static method: "getSimplificationOnTheFly" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::getSimplificationOnTheFly"
// cWrapperName: "CasADi__CasadiOptions__getSimplificationOnTheFly"
// protoArgs: "()"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CasadiOptions__getSimplificationOnTheFly()"
// call: "CasADi::CasadiOptions::getSimplificationOnTheFly()"
extern "C"
    int CasADi__CasadiOptions__getSimplificationOnTheFly();
int CasADi__CasadiOptions__getSimplificationOnTheFly(){

    return WrapReturn< int, bool >::wrapReturn( CasADi::CasadiOptions::getSimplificationOnTheFly() );
}


// ================== Static method: "startProfiling" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::startProfiling"
// cWrapperName: "CasADi__CasadiOptions__startProfiling"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__startProfiling(std::string* x0)"
// call: "CasADi::CasadiOptions::startProfiling(x0_)"
extern "C"
    void CasADi__CasadiOptions__startProfiling(std::string* x0);
void CasADi__CasadiOptions__startProfiling(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    CasADi::CasadiOptions::startProfiling(x0_);
}


// ================== Static method: "stopProfiling" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::stopProfiling"
// cWrapperName: "CasADi__CasadiOptions__stopProfiling"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__stopProfiling()"
// call: "CasADi::CasadiOptions::stopProfiling()"
extern "C"
    void CasADi__CasadiOptions__stopProfiling();
void CasADi__CasadiOptions__stopProfiling(){

    CasADi::CasadiOptions::stopProfiling();
}


// ================== Static method: "setProfilingBinary" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setProfilingBinary"
// cWrapperName: "CasADi__CasadiOptions__setProfilingBinary"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setProfilingBinary(int x0)"
// call: "CasADi::CasadiOptions::setProfilingBinary(x0_)"
extern "C"
    void CasADi__CasadiOptions__setProfilingBinary(int x0);
void CasADi__CasadiOptions__setProfilingBinary(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::CasadiOptions::setProfilingBinary(x0_);
}


// ================== Static method: "getProfilingBinary" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::getProfilingBinary"
// cWrapperName: "CasADi__CasadiOptions__getProfilingBinary"
// protoArgs: "()"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CasadiOptions__getProfilingBinary()"
// call: "CasADi::CasadiOptions::getProfilingBinary()"
extern "C"
    int CasADi__CasadiOptions__getProfilingBinary();
int CasADi__CasadiOptions__getProfilingBinary(){

    return WrapReturn< int, bool >::wrapReturn( CasADi::CasadiOptions::getProfilingBinary() );
}


// ================== Static method: "setPurgeSeeds" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setPurgeSeeds"
// cWrapperName: "CasADi__CasadiOptions__setPurgeSeeds"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setPurgeSeeds(int x0)"
// call: "CasADi::CasadiOptions::setPurgeSeeds(x0_)"
extern "C"
    void CasADi__CasadiOptions__setPurgeSeeds(int x0);
void CasADi__CasadiOptions__setPurgeSeeds(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::CasadiOptions::setPurgeSeeds(x0_);
}


// ================== Static method: "setPurgeSeeds'" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setPurgeSeeds'"
// cWrapperName: "CasADi__CasadiOptions__setPurgeSeeds_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CasadiOptions__setPurgeSeeds_TIC()"
// call: "CasADi::CasadiOptions::setPurgeSeeds()"
extern "C"
    int CasADi__CasadiOptions__setPurgeSeeds_TIC();
int CasADi__CasadiOptions__setPurgeSeeds_TIC(){

    return WrapReturn< int, bool >::wrapReturn( CasADi::CasadiOptions::setPurgeSeeds() );
}


// ================== Static method: "setAllowedInternalAPI" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setAllowedInternalAPI"
// cWrapperName: "CasADi__CasadiOptions__setAllowedInternalAPI"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setAllowedInternalAPI(int x0)"
// call: "CasADi::CasadiOptions::setAllowedInternalAPI(x0_)"
extern "C"
    void CasADi__CasadiOptions__setAllowedInternalAPI(int x0);
void CasADi__CasadiOptions__setAllowedInternalAPI(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::CasadiOptions::setAllowedInternalAPI(x0_);
}


// ================== Static method: "getAllowedInternalAPI" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::getAllowedInternalAPI"
// cWrapperName: "CasADi__CasadiOptions__getAllowedInternalAPI"
// protoArgs: "()"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CasadiOptions__getAllowedInternalAPI()"
// call: "CasADi::CasadiOptions::getAllowedInternalAPI()"
extern "C"
    int CasADi__CasadiOptions__getAllowedInternalAPI();
int CasADi__CasadiOptions__getAllowedInternalAPI(){

    return WrapReturn< int, bool >::wrapReturn( CasADi::CasadiOptions::getAllowedInternalAPI() );
}


// ================== delete CasadiClass Slice===============
// classType: CasadiClass Slice
extern "C"
    void delete_CasADi__Slice(CasADi::Slice* obj);
void delete_CasADi__Slice(CasADi::Slice* obj){
    delete obj;
}

// ================== Static method: "isSlice" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice::isSlice"
// cWrapperName: "CasADi__Slice__isSlice"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Slice__isSlice(std::vector< int >* x0)"
// call: "CasADi::Slice::isSlice(x0_)"
extern "C"
    int CasADi__Slice__isSlice(std::vector< int >* x0);
int CasADi__Slice__isSlice(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::Slice::isSlice(x0_) );
}


// ================== Static method: "isSlice2" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice::isSlice2"
// cWrapperName: "CasADi__Slice__isSlice2"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Slice__isSlice2(std::vector< int >* x0)"
// call: "CasADi::Slice::isSlice2(x0_)"
extern "C"
    int CasADi__Slice__isSlice2(std::vector< int >* x0);
int CasADi__Slice__isSlice2(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::Slice::isSlice2(x0_) );
}


// ================== Normal method: "getAll" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice::getAll"
// cWrapperName: "CasADi__Slice__getAll"
// protoArgs: "(CasADi::Slice* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Slice__getAll(CasADi::Slice* obj, int x0)"
// call: "obj->getAll(x0_)"
extern "C"
    std::vector< int >* CasADi__Slice__getAll(CasADi::Slice* obj, int x0);
std::vector< int >* CasADi__Slice__getAll(CasADi::Slice* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getAll(x0_) );
}


// ================== Normal method: "getAll'" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice::getAll'"
// cWrapperName: "CasADi__Slice__getAll_TIC"
// protoArgs: "(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_TIC(CasADi::Slice* obj, CasADi::Slice* x0, int x1)"
// call: "obj->getAll(x0_, x1_)"
extern "C"
    std::vector< int >* CasADi__Slice__getAll_TIC(CasADi::Slice* obj, CasADi::Slice* x0, int x1);
std::vector< int >* CasADi__Slice__getAll_TIC(CasADi::Slice* obj, CasADi::Slice* x0, int x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getAll(x0_, x1_) );
}


// ================== Normal method: "operator ==" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice::operator =="
// cWrapperName: "CasADi__Slice__operator_equals"
// protoArgs: "(CasADi::Slice* obj, CasADi::Slice* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Slice__operator_equals(CasADi::Slice* obj, CasADi::Slice* x0)"
// call: "obj->operator ==(x0_)"
extern "C"
    int CasADi__Slice__operator_equals(CasADi::Slice* obj, CasADi::Slice* x0);
int CasADi__Slice__operator_equals(CasADi::Slice* obj, CasADi::Slice* x0){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->operator ==(x0_) );
}


// ================== Normal method: "operator !=" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice::operator !="
// cWrapperName: "CasADi__Slice__operator_nequals"
// protoArgs: "(CasADi::Slice* obj, CasADi::Slice* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Slice__operator_nequals(CasADi::Slice* obj, CasADi::Slice* x0)"
// call: "obj->operator !=(x0_)"
extern "C"
    int CasADi__Slice__operator_nequals(CasADi::Slice* obj, CasADi::Slice* x0);
int CasADi__Slice__operator_nequals(CasADi::Slice* obj, CasADi::Slice* x0){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->operator !=(x0_) );
}


// ================== Constructor method: "Slice" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice"
// cWrapperName: "CasADi__Slice__Slice"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Slice
// cWrapperRetType: "CasADi::Slice*"
// proto: "CasADi::Slice* CasADi__Slice__Slice()"
// call: "CasADi::Slice()"
extern "C"
    CasADi::Slice* CasADi__Slice__Slice();
CasADi::Slice* CasADi__Slice__Slice(){

    return WrapReturn< CasADi::Slice*, CasADi::Slice >::wrapReturn( CasADi::Slice() );
}


// ================== Constructor method: "Slice'" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice"
// cWrapperName: "CasADi__Slice__Slice_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass Slice
// cWrapperRetType: "CasADi::Slice*"
// proto: "CasADi::Slice* CasADi__Slice__Slice_TIC(int x0)"
// call: "CasADi::Slice(x0_)"
extern "C"
    CasADi::Slice* CasADi__Slice__Slice_TIC(int x0);
CasADi::Slice* CasADi__Slice__Slice_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Slice*, CasADi::Slice >::wrapReturn( CasADi::Slice(x0_) );
}


// ================== Constructor method: "Slice''" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice"
// cWrapperName: "CasADi__Slice__Slice_TIC_TIC"
// protoArgs: "(int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Slice
// cWrapperRetType: "CasADi::Slice*"
// proto: "CasADi::Slice* CasADi__Slice__Slice_TIC_TIC(int x0, int x1, int x2)"
// call: "CasADi::Slice(x0_, x1_, x2_)"
extern "C"
    CasADi::Slice* CasADi__Slice__Slice_TIC_TIC(int x0, int x1, int x2);
CasADi::Slice* CasADi__Slice__Slice_TIC_TIC(int x0, int x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Slice*, CasADi::Slice >::wrapReturn( CasADi::Slice(x0_, x1_, x2_) );
}


// ================== Constructor method: "Slice'''" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice"
// cWrapperName: "CasADi__Slice__Slice_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Slice
// cWrapperRetType: "CasADi::Slice*"
// proto: "CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC(int x0, int x1)"
// call: "CasADi::Slice(x0_, x1_)"
extern "C"
    CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC(int x0, int x1);
CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Slice*, CasADi::Slice >::wrapReturn( CasADi::Slice(x0_, x1_) );
}


// ================== Constructor method: "Slice''''" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice"
// cWrapperName: "CasADi__Slice__Slice_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Slice
// cWrapperRetType: "CasADi::Slice*"
// proto: "CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::Slice(x0_)"
extern "C"
    CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC_TIC(std::vector< int >* x0);
CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC_TIC(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Slice*, CasADi::Slice >::wrapReturn( CasADi::Slice(x0_) );
}


// ================== Constructor method: "Slice'''''" ===============
// class: "CasADi::Slice"
// cppName: "CasADi::Slice"
// cWrapperName: "CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0, CasADi::Slice* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Slice
// cWrapperRetType: "CasADi::Slice*"
// proto: "CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, CasADi::Slice* x1)"
// call: "CasADi::Slice(x0_, x1_)"
extern "C"
    CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, CasADi::Slice* x1);
CasADi::Slice* CasADi__Slice__Slice_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, CasADi::Slice* x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::Slice& x1_ = Marshaling<CasADi::Slice&,CasADi::Slice*>::marshal(x1);

    return WrapReturn< CasADi::Slice*, CasADi::Slice >::wrapReturn( CasADi::Slice(x0_, x1_) );
}


// ================== delete CasadiClass CustomEvaluate===============
// classType: CasadiClass CustomEvaluate
extern "C"
    void delete_CasADi__CustomEvaluate(CasADi::CustomEvaluate* obj);
void delete_CasADi__CustomEvaluate(CasADi::CustomEvaluate* obj){
    delete obj;
}

// ================== Constructor method: "CustomEvaluate" ===============
// class: "CasADi::CustomEvaluate"
// cppName: "CasADi::CustomEvaluate"
// cWrapperName: "CasADi__CustomEvaluate__CustomEvaluate"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass CustomEvaluate
// cWrapperRetType: "CasADi::CustomEvaluate*"
// proto: "CasADi::CustomEvaluate* CasADi__CustomEvaluate__CustomEvaluate()"
// call: "CasADi::CustomEvaluate()"
extern "C"
    CasADi::CustomEvaluate* CasADi__CustomEvaluate__CustomEvaluate();
CasADi::CustomEvaluate* CasADi__CustomEvaluate__CustomEvaluate(){

    return WrapReturn< CasADi::CustomEvaluate*, CasADi::CustomEvaluate >::wrapReturn( CasADi::CustomEvaluate() );
}


// ================== delete CasadiClass GenMX===============
// classType: CasadiClass GenMX
extern "C"
    void delete_CasADi__GenericMatrix_CasADi__MX_(CasADi::GenericMatrix< CasADi::MX >* obj);
void delete_CasADi__GenericMatrix_CasADi__MX_(CasADi::GenericMatrix< CasADi::MX >* obj){
    delete obj;
}

// ================== Normal method: "size" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::size"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___size"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___size(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___size(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___size(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size() );
}


// ================== Normal method: "sizeL" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sizeL"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sizeL"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___sizeL(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->sizeL()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___sizeL(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___sizeL(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeL() );
}


// ================== Normal method: "sizeU" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sizeU"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sizeU"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___sizeU(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->sizeU()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___sizeU(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___sizeU(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeU() );
}


// ================== Normal method: "sizeD" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sizeD"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sizeD"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___sizeD(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->sizeD()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___sizeD(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___sizeD(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeD() );
}


// ================== Normal method: "numel" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::numel"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___numel"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___numel(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___numel(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___numel(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->numel() );
}


// ================== Normal method: "size1" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::size1"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___size1"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___size1(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___size1(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___size1(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size1() );
}


// ================== Normal method: "size2" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::size2"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___size2"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___size2(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___size2(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___size2(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size2() );
}


// ================== Normal method: "size'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::size'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___size_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::SparsityType x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___size_TIC(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::SparsityType x0)"
// call: "obj->size(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___size_TIC(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::SparsityType x0);
int CasADi__GenericMatrix_CasADi__MX___size_TIC(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::SparsityType x0){
    CasADi::SparsityType x0_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->size(x0_) );
}


// ================== Normal method: "dimString" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::dimString"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___dimString"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericMatrix_CasADi__MX___dimString(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->dimString()"
extern "C"
    std::string* CasADi__GenericMatrix_CasADi__MX___dimString(CasADi::GenericMatrix< CasADi::MX >* obj);
std::string* CasADi__GenericMatrix_CasADi__MX___dimString(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->dimString() );
}


// ================== Normal method: "isEmpty" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isEmpty"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isEmpty"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isEmpty(CasADi::GenericMatrix< CasADi::MX >* obj, int x0)"
// call: "obj->isEmpty(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isEmpty(CasADi::GenericMatrix< CasADi::MX >* obj, int x0);
int CasADi__GenericMatrix_CasADi__MX___isEmpty(CasADi::GenericMatrix< CasADi::MX >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty(x0_) );
}


// ================== Normal method: "isEmpty'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isEmpty'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isEmpty()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty() );
}


// ================== Normal method: "isDense" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isDense"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isDense"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isDense(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isDense()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isDense(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isDense(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDense() );
}


// ================== Normal method: "isScalar" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isScalar"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isScalar"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isScalar(CasADi::GenericMatrix< CasADi::MX >* obj, int x0)"
// call: "obj->isScalar(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isScalar(CasADi::GenericMatrix< CasADi::MX >* obj, int x0);
int CasADi__GenericMatrix_CasADi__MX___isScalar(CasADi::GenericMatrix< CasADi::MX >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar(x0_) );
}


// ================== Normal method: "isScalar'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isScalar'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isScalar_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isScalar_TIC(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isScalar()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isScalar_TIC(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isScalar_TIC(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar() );
}


// ================== Normal method: "isSquare" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isSquare"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isSquare"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isSquare(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isSquare()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isSquare(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isSquare(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSquare() );
}


// ================== Normal method: "isVector" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isVector"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isVector"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isVector(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isVector()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isVector(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isVector(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isVector() );
}


// ================== Normal method: "isTriu" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isTriu"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isTriu"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isTriu(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isTriu()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isTriu(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isTriu(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTriu() );
}


// ================== Normal method: "isTril" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::isTril"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___isTril"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__MX___isTril(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->isTril()"
extern "C"
    int CasADi__GenericMatrix_CasADi__MX___isTril(CasADi::GenericMatrix< CasADi::MX >* obj);
int CasADi__GenericMatrix_CasADi__MX___isTril(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTril() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sparsityRef"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sparsityRef"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__GenericMatrix_CasADi__MX___sparsityRef(CasADi::GenericMatrix< CasADi::MX >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__GenericMatrix_CasADi__MX___sparsityRef(CasADi::GenericMatrix< CasADi::MX >* obj);
CasADi::Sparsity* CasADi__GenericMatrix_CasADi__MX___sparsityRef(CasADi::GenericMatrix< CasADi::MX >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Static method: "sym" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym"
// protoArgs: "(std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym(std::string* x0, int x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym(std::string* x0, int x1, int x2);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym(std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC"
// protoArgs: "(std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC(std::string* x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC(std::string* x0, int x1);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC(std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_) );
}


// ================== Static method: "sym''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC(std::string* x0)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC(std::string* x0);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_) );
}


// ================== Static method: "sym'''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_) );
}


// ================== Static method: "sym''''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2);
std::vector< CasADi::MX* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'''''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym'''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);
std::vector< CasADi::MX* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (CasadiClass MX))
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< CasADi::MX* >* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym'''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sym'''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (CasadiClass MX))
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< CasADi::MX* >* >* CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sym(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "sparse" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sparse"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sparse"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sparse(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse(int x0, int x1);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sparse'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::MX >::sparse(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse_TIC(int x0);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sparse(x0_) );
}


// ================== Static method: "sparse''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::sparse''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::MX >::sparse()"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC();
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC(){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::sparse() );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::zeros"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___zeros"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::MX >::zeros(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros(int x0, int x1);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::zeros(x0_, x1_) );
}


// ================== Static method: "zeros'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::zeros'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___zeros_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::MX >::zeros(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC(int x0);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::zeros(x0_) );
}


// ================== Static method: "zeros''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::zeros''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::MX >::zeros()"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC();
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC(){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::zeros() );
}


// ================== Static method: "zeros'''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::zeros'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::MX >::zeros(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::ones"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___ones"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::MX >::ones(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones(int x0, int x1);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::ones(x0_, x1_) );
}


// ================== Static method: "ones'" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::ones'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___ones_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::MX >::ones(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC(int x0);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::ones(x0_) );
}


// ================== Static method: "ones''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::ones''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::MX >::ones()"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC();
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC(){

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::ones() );
}


// ================== Static method: "ones'''" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::ones'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::MX >::ones(x0_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::GenericMatrix< CasADi::MX >::ones(x0_) );
}


// ================== Normal method: "mul_smart" ===============
// class: "CasADi::GenericMatrix< CasADi::MX >"
// cppName: "CasADi::GenericMatrix< CasADi::MX >::mul_smart"
// cWrapperName: "CasADi__GenericMatrix_CasADi__MX___mul_smart"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::MX* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__GenericMatrix_CasADi__MX___mul_smart(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::MX* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__GenericMatrix_CasADi__MX___mul_smart(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::MX* x0, CasADi::Sparsity* x1);
CasADi::MX* CasADi__GenericMatrix_CasADi__MX___mul_smart(CasADi::GenericMatrix< CasADi::MX >* obj, CasADi::MX* x0, CasADi::Sparsity* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->mul_smart(x0_, x1_) );
}


// ================== delete CasadiClass ControlSimulator===============
// classType: CasadiClass ControlSimulator
extern "C"
    void delete_CasADi__ControlSimulator(CasADi::ControlSimulator* obj);
void delete_CasADi__ControlSimulator(CasADi::ControlSimulator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator::checkNode"
// cWrapperName: "CasADi__ControlSimulator__checkNode"
// protoArgs: "(CasADi::ControlSimulator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__ControlSimulator__checkNode(CasADi::ControlSimulator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__ControlSimulator__checkNode(CasADi::ControlSimulator* obj);
int CasADi__ControlSimulator__checkNode(CasADi::ControlSimulator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getMinorT" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator::getMinorT"
// cWrapperName: "CasADi__ControlSimulator__getMinorT"
// protoArgs: "(CasADi::ControlSimulator* obj)"
// args: "()"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__ControlSimulator__getMinorT(CasADi::ControlSimulator* obj)"
// call: "obj->getMinorT()"
extern "C"
    std::vector< double >* CasADi__ControlSimulator__getMinorT(CasADi::ControlSimulator* obj);
std::vector< double >* CasADi__ControlSimulator__getMinorT(CasADi::ControlSimulator* obj){

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->getMinorT() );
}


// ================== Normal method: "getMinorU" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator::getMinorU"
// cWrapperName: "CasADi__ControlSimulator__getMinorU"
// protoArgs: "(CasADi::ControlSimulator* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__ControlSimulator__getMinorU(CasADi::ControlSimulator* obj)"
// call: "obj->getMinorU()"
extern "C"
    CasADi::Matrix< double >* CasADi__ControlSimulator__getMinorU(CasADi::ControlSimulator* obj);
CasADi::Matrix< double >* CasADi__ControlSimulator__getMinorU(CasADi::ControlSimulator* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getMinorU() );
}


// ================== Normal method: "getMajorIndex" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator::getMajorIndex"
// cWrapperName: "CasADi__ControlSimulator__getMajorIndex"
// protoArgs: "(CasADi::ControlSimulator* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__ControlSimulator__getMajorIndex(CasADi::ControlSimulator* obj)"
// call: "obj->getMajorIndex()"
extern "C"
    std::vector< int >* CasADi__ControlSimulator__getMajorIndex(CasADi::ControlSimulator* obj);
std::vector< int >* CasADi__ControlSimulator__getMajorIndex(CasADi::ControlSimulator* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getMajorIndex() );
}


// ================== Constructor method: "ControlSimulator" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator"
// cWrapperName: "CasADi__ControlSimulator__ControlSimulator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass ControlSimulator
// cWrapperRetType: "CasADi::ControlSimulator*"
// proto: "CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator()"
// call: "CasADi::ControlSimulator()"
extern "C"
    CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator();
CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator(){

    return WrapReturn< CasADi::ControlSimulator*, CasADi::ControlSimulator >::wrapReturn( CasADi::ControlSimulator() );
}


// ================== Constructor method: "ControlSimulator'" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator"
// cWrapperName: "CasADi__ControlSimulator__ControlSimulator_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass ControlSimulator
// cWrapperRetType: "CasADi::ControlSimulator*"
// proto: "CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC(CasADi::Function* x0, CasADi::Function* x1, std::vector< double >* x2)"
// call: "CasADi::ControlSimulator(x0_, x1_, x2_)"
extern "C"
    CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC(CasADi::Function* x0, CasADi::Function* x1, std::vector< double >* x2);
CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC(CasADi::Function* x0, CasADi::Function* x1, std::vector< double >* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

    return WrapReturn< CasADi::ControlSimulator*, CasADi::ControlSimulator >::wrapReturn( CasADi::ControlSimulator(x0_, x1_, x2_) );
}


// ================== Constructor method: "ControlSimulator''" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator"
// cWrapperName: "CasADi__ControlSimulator__ControlSimulator_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass ControlSimulator
// cWrapperRetType: "CasADi::ControlSimulator*"
// proto: "CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::ControlSimulator(x0_, x1_, x2_)"
extern "C"
    CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2);
CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::ControlSimulator*, CasADi::ControlSimulator >::wrapReturn( CasADi::ControlSimulator(x0_, x1_, x2_) );
}


// ================== Constructor method: "ControlSimulator'''" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator"
// cWrapperName: "CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass ControlSimulator
// cWrapperRetType: "CasADi::ControlSimulator*"
// proto: "CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC(CasADi::Function* x0, std::vector< double >* x1)"
// call: "CasADi::ControlSimulator(x0_, x1_)"
extern "C"
    CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC(CasADi::Function* x0, std::vector< double >* x1);
CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC(CasADi::Function* x0, std::vector< double >* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    return WrapReturn< CasADi::ControlSimulator*, CasADi::ControlSimulator >::wrapReturn( CasADi::ControlSimulator(x0_, x1_) );
}


// ================== Constructor method: "ControlSimulator''''" ===============
// class: "CasADi::ControlSimulator"
// cppName: "CasADi::ControlSimulator"
// cWrapperName: "CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass ControlSimulator
// cWrapperRetType: "CasADi::ControlSimulator*"
// proto: "CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::ControlSimulator(x0_, x1_)"
extern "C"
    CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Matrix< double >* x1);
CasADi::ControlSimulator* CasADi__ControlSimulator__ControlSimulator_TIC_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Matrix< double >* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::ControlSimulator*, CasADi::ControlSimulator >::wrapReturn( CasADi::ControlSimulator(x0_, x1_) );
}


// ================== delete CasadiClass IMatrix===============
// classType: CasadiClass IMatrix
extern "C"
    void delete_CasADi__Matrix_int_(CasADi::Matrix< int >* obj);
void delete_CasADi__Matrix_int_(CasADi::Matrix< int >* obj){
    delete obj;
}

// ================== Normal method: "sanityCheck" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sanityCheck"
// cWrapperName: "CasADi__Matrix_int___sanityCheck"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___sanityCheck(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
extern "C"
    void CasADi__Matrix_int___sanityCheck(CasADi::Matrix< int >* obj, int x0);
void CasADi__Matrix_int___sanityCheck(CasADi::Matrix< int >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
}


// ================== Normal method: "sanityCheck'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sanityCheck'"
// cWrapperName: "CasADi__Matrix_int___sanityCheck_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___sanityCheck_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->sanityCheck()"
extern "C"
    void CasADi__Matrix_int___sanityCheck_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___sanityCheck_TIC(CasADi::Matrix< int >* obj){

    obj->sanityCheck();
}


// ================== Normal method: "at" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::at"
// cWrapperName: "CasADi__Matrix_int___at"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___at(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->at(x0_)"
extern "C"
    int CasADi__Matrix_int___at(CasADi::Matrix< int >* obj, int x0);
int CasADi__Matrix_int___at(CasADi::Matrix< int >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->at(x0_) );
}


// ================== Normal method: "elem" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::elem"
// cWrapperName: "CasADi__Matrix_int___elem"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___elem(CasADi::Matrix< int >* obj, int x0, int x1)"
// call: "obj->elem(x0_, x1_)"
extern "C"
    int CasADi__Matrix_int___elem(CasADi::Matrix< int >* obj, int x0, int x1);
int CasADi__Matrix_int___elem(CasADi::Matrix< int >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( obj->elem(x0_, x1_) );
}


// ================== Normal method: "elem'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::elem'"
// cWrapperName: "CasADi__Matrix_int___elem_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___elem_TIC(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->elem(x0_)"
extern "C"
    int CasADi__Matrix_int___elem_TIC(CasADi::Matrix< int >* obj, int x0);
int CasADi__Matrix_int___elem_TIC(CasADi::Matrix< int >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->elem(x0_) );
}


// ================== Normal method: "hasNZ" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::hasNZ"
// cWrapperName: "CasADi__Matrix_int___hasNZ"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___hasNZ(CasADi::Matrix< int >* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
extern "C"
    int CasADi__Matrix_int___hasNZ(CasADi::Matrix< int >* obj, int x0, int x1);
int CasADi__Matrix_int___hasNZ(CasADi::Matrix< int >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( obj->hasNZ(x0_, x1_) );
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__nonzero__"
// cWrapperName: "CasADi__Matrix_int_____nonzero__"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int_____nonzero__(CasADi::Matrix< int >* obj)"
// call: "obj->__nonzero__()"
extern "C"
    int CasADi__Matrix_int_____nonzero__(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int_____nonzero__(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->__nonzero__() );
}


// ================== Normal method: "setSub" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub"
// cWrapperName: "CasADi__Matrix_int___setSub"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, int x2);
void CasADi__Matrix_int___setSub(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, int x2);
void CasADi__Matrix_int___setSub_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::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_);
}


// ================== Normal method: "setSub''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, std::vector< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, int x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::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_);
}


// ================== Normal method: "setSub'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< 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);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, std::vector< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Slice* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Slice* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Slice* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Slice* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub''''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'''''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub''''''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'''''''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub''''''''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, int x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSub'''''''''''''"
// cWrapperName: "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1, int x2);
void CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setNZ" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setNZ"
// cWrapperName: "CasADi__Matrix_int___setNZ"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setNZ(CasADi::Matrix< int >* obj, int x0, CasADi::Matrix< int >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___setNZ(CasADi::Matrix< int >* obj, int x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___setNZ(CasADi::Matrix< int >* obj, int x0, CasADi::Matrix< int >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setNZ'"
// cWrapperName: "CasADi__Matrix_int___setNZ_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setNZ_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::Matrix< int >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___setNZ_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___setNZ_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::Matrix< int >* x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setNZ''"
// cWrapperName: "CasADi__Matrix_int___setNZ_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setNZ_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___setNZ_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___setNZ_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setNZ'''"
// cWrapperName: "CasADi__Matrix_int___setNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setNZ_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___setNZ_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___setNZ_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "append" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::append"
// cWrapperName: "CasADi__Matrix_int___append"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___append(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->append(x0_)"
extern "C"
    void CasADi__Matrix_int___append(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
void CasADi__Matrix_int___append(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    obj->append(x0_);
}


// ================== Normal method: "appendColumns" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::appendColumns"
// cWrapperName: "CasADi__Matrix_int___appendColumns"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___appendColumns(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->appendColumns(x0_)"
extern "C"
    void CasADi__Matrix_int___appendColumns(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
void CasADi__Matrix_int___appendColumns(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    obj->appendColumns(x0_);
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nz_indexed_one_based_assignment"
// cWrapperName: "CasADi__Matrix_int___nz_indexed_one_based_assignment"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___nz_indexed_one_based_assignment(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___nz_indexed_one_based_assignment(CasADi::Matrix< int >* obj, int x0, int const * x1);
void CasADi__Matrix_int___nz_indexed_one_based_assignment(CasADi::Matrix< int >* obj, int x0, int const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nz_indexed_zero_based_assignment"
// cWrapperName: "CasADi__Matrix_int___nz_indexed_zero_based_assignment"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___nz_indexed_zero_based_assignment(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___nz_indexed_zero_based_assignment(CasADi::Matrix< int >* obj, int x0, int const * x1);
void CasADi__Matrix_int___nz_indexed_zero_based_assignment(CasADi::Matrix< int >* obj, int x0, int const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nz_indexed_assignment"
// cWrapperName: "CasADi__Matrix_int___nz_indexed_assignment"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___nz_indexed_assignment(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___nz_indexed_assignment(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___nz_indexed_assignment(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_one_based_assignment"
// cWrapperName: "CasADi__Matrix_int___indexed_one_based_assignment"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_one_based_assignment(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_one_based_assignment(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___indexed_one_based_assignment(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_zero_based_assignment"
// cWrapperName: "CasADi__Matrix_int___indexed_zero_based_assignment"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_zero_based_assignment(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_zero_based_assignment(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___indexed_zero_based_assignment(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_one_based_assignment'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nz_indexed_one_based_assignment'"
// cWrapperName: "CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_zero_based_assignment'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nz_indexed_zero_based_assignment'"
// cWrapperName: "CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nz_indexed_assignment'"
// cWrapperName: "CasADi__Matrix_int___nz_indexed_assignment_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___nz_indexed_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___nz_indexed_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___nz_indexed_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_one_based_assignment'"
// cWrapperName: "CasADi__Matrix_int___indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_one_based_assignment_TIC(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_one_based_assignment_TIC(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2);
void CasADi__Matrix_int___indexed_one_based_assignment_TIC(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int const & x2_ = Marshaling<int const &,int const *>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_zero_based_assignment'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_zero_based_assignment'"
// cWrapperName: "CasADi__Matrix_int___indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_zero_based_assignment_TIC(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_zero_based_assignment_TIC(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2);
void CasADi__Matrix_int___indexed_zero_based_assignment_TIC(CasADi::Matrix< int >* obj, int x0, int x1, int const * x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int const & x2_ = Marshaling<int const &,int const *>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment'"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment'''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment''''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment'''''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment''''''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment'''''''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, CasADi::Matrix< int >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, CasADi::Matrix< int >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_one_based_assignment''"
// cWrapperName: "CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< int >* obj, int x0, int const * x1);
void CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< int >* obj, int x0, int const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_zero_based_assignment''"
// cWrapperName: "CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< int >* obj, int x0, int const * x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< int >* obj, int x0, int const * x1);
void CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< int >* obj, int x0, int const * x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment''''''''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment'''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::indexed_assignment'''''''''"
// cWrapperName: "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1);
void CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "setZero" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setZero"
// cWrapperName: "CasADi__Matrix_int___setZero"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setZero(CasADi::Matrix< int >* obj)"
// call: "obj->setZero()"
extern "C"
    void CasADi__Matrix_int___setZero(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___setZero(CasADi::Matrix< int >* obj){

    obj->setZero();
}


// ================== Normal method: "setAll" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setAll"
// cWrapperName: "CasADi__Matrix_int___setAll"
// protoArgs: "(CasADi::Matrix< int >* obj, int const * x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setAll(CasADi::Matrix< int >* obj, int const * x0)"
// call: "obj->setAll(x0_)"
extern "C"
    void CasADi__Matrix_int___setAll(CasADi::Matrix< int >* obj, int const * x0);
void CasADi__Matrix_int___setAll(CasADi::Matrix< int >* obj, int const * x0){
    int const & x0_ = Marshaling<int const &,int const *>::marshal(x0);

    obj->setAll(x0_);
}


// ================== Normal method: "setSparse" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSparse"
// cWrapperName: "CasADi__Matrix_int___setSparse"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___setSparse(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___setSparse(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, int x1);
CasADi::Matrix< int >* CasADi__Matrix_int___setSparse(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->setSparse(x0_, x1_) );
}


// ================== Normal method: "setSparse'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setSparse'"
// cWrapperName: "CasADi__Matrix_int___setSparse_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___setSparse_TIC(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___setSparse_TIC(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___setSparse_TIC(CasADi::Matrix< int >* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->setSparse(x0_) );
}


// ================== Normal method: "densify" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::densify"
// cWrapperName: "CasADi__Matrix_int___densify"
// protoArgs: "(CasADi::Matrix< int >* obj, int const * x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___densify(CasADi::Matrix< int >* obj, int const * x0)"
// call: "obj->densify(x0_)"
extern "C"
    void CasADi__Matrix_int___densify(CasADi::Matrix< int >* obj, int const * x0);
void CasADi__Matrix_int___densify(CasADi::Matrix< int >* obj, int const * x0){
    int const & x0_ = Marshaling<int const &,int const *>::marshal(x0);

    obj->densify(x0_);
}


// ================== Normal method: "densify'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::densify'"
// cWrapperName: "CasADi__Matrix_int___densify_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___densify_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->densify()"
extern "C"
    void CasADi__Matrix_int___densify_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___densify_TIC(CasADi::Matrix< int >* obj){

    obj->densify();
}


// ================== Normal method: "sparsify" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sparsify"
// cWrapperName: "CasADi__Matrix_int___sparsify"
// protoArgs: "(CasADi::Matrix< int >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___sparsify(CasADi::Matrix< int >* obj, double x0)"
// call: "obj->sparsify(x0_)"
extern "C"
    void CasADi__Matrix_int___sparsify(CasADi::Matrix< int >* obj, double x0);
void CasADi__Matrix_int___sparsify(CasADi::Matrix< int >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->sparsify(x0_);
}


// ================== Normal method: "sparsify'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sparsify'"
// cWrapperName: "CasADi__Matrix_int___sparsify_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___sparsify_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->sparsify()"
extern "C"
    void CasADi__Matrix_int___sparsify_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___sparsify_TIC(CasADi::Matrix< int >* obj){

    obj->sparsify();
}


// ================== Normal method: "operator +" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::operator +"
// cWrapperName: "CasADi__Matrix_int___operator_plus"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___operator_plus(CasADi::Matrix< int >* obj)"
// call: "obj->operator +()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___operator_plus(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___operator_plus(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->operator +() );
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::operator -"
// cWrapperName: "CasADi__Matrix_int___operator_minus"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___operator_minus(CasADi::Matrix< int >* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___operator_minus(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___operator_minus(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->operator -() );
}


// ================== Static method: "binary" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::binary"
// cWrapperName: "CasADi__Matrix_int___binary"
// protoArgs: "(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___binary(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___binary(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
CasADi::Matrix< int >* CasADi__Matrix_int___binary(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::binary(x0_, x1_, x2_) );
}


// ================== Static method: "unary" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::unary"
// cWrapperName: "CasADi__Matrix_int___unary"
// protoArgs: "(int x0, CasADi::Matrix< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___unary(int x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::Matrix< int >::unary(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___unary(int x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__Matrix_int___unary(int x0, CasADi::Matrix< int >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::unary(x0_, x1_) );
}


// ================== Static method: "scalar_matrix" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::scalar_matrix"
// cWrapperName: "CasADi__Matrix_int___scalar_matrix"
// protoArgs: "(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___scalar_matrix(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::scalar_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___scalar_matrix(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
CasADi::Matrix< int >* CasADi__Matrix_int___scalar_matrix(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::scalar_matrix(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_scalar" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::matrix_scalar"
// cWrapperName: "CasADi__Matrix_int___matrix_scalar"
// protoArgs: "(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___matrix_scalar(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::matrix_scalar(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___matrix_scalar(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
CasADi::Matrix< int >* CasADi__Matrix_int___matrix_scalar(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::matrix_scalar(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_matrix" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::matrix_matrix"
// cWrapperName: "CasADi__Matrix_int___matrix_matrix"
// protoArgs: "(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___matrix_matrix(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::matrix_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___matrix_matrix(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
CasADi::Matrix< int >* CasADi__Matrix_int___matrix_matrix(int x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::matrix_matrix(x0_, x1_, x2_) );
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__add__"
// cWrapperName: "CasADi__Matrix_int_____add__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____add__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____add__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____add__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__sub__"
// cWrapperName: "CasADi__Matrix_int_____sub__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____sub__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____sub__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____sub__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__mul__"
// cWrapperName: "CasADi__Matrix_int_____mul__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____mul__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____mul__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____mul__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__div__"
// cWrapperName: "CasADi__Matrix_int_____div__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____div__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____div__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____div__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__lt__"
// cWrapperName: "CasADi__Matrix_int_____lt__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____lt__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____lt__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____lt__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__le__"
// cWrapperName: "CasADi__Matrix_int_____le__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____le__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____le__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____le__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__eq__"
// cWrapperName: "CasADi__Matrix_int_____eq__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____eq__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____eq__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____eq__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__ne__"
// cWrapperName: "CasADi__Matrix_int_____ne__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____ne__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____ne__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____ne__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__truediv__"
// cWrapperName: "CasADi__Matrix_int_____truediv__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____truediv__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____truediv__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____truediv__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__pow__"
// cWrapperName: "CasADi__Matrix_int_____pow__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____pow__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____pow__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____pow__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__constpow__"
// cWrapperName: "CasADi__Matrix_int_____constpow__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____constpow__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____constpow__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____constpow__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__mpower__"
// cWrapperName: "CasADi__Matrix_int_____mpower__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____mpower__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____mpower__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____mpower__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__mpower__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__mrdivide__"
// cWrapperName: "CasADi__Matrix_int_____mrdivide__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____mrdivide__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____mrdivide__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____mrdivide__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "mul_full" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_full"
// cWrapperName: "CasADi__Matrix_int___mul_full"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___mul_full(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___mul_full(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__Matrix_int___mul_full(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->mul_full(x0_, x1_) );
}


// ================== Normal method: "mul_full'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_full'"
// cWrapperName: "CasADi__Matrix_int___mul_full_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___mul_full_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->mul_full(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___mul_full_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___mul_full_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->mul_full(x0_) );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul"
// cWrapperName: "CasADi__Matrix_int___mul"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___mul(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___mul(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__Matrix_int___mul(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->mul(x0_, x1_) );
}


// ================== Normal method: "mul'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul'"
// cWrapperName: "CasADi__Matrix_int___mul_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___mul_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___mul_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___mul_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->mul(x0_) );
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_no_alloc_nn"
// cWrapperName: "CasADi__Matrix_int___mul_no_alloc_nn"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___mul_no_alloc_nn(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___mul_no_alloc_nn(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___mul_no_alloc_nn(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int >& x2_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x2);

    CasADi::Matrix< int >::mul_no_alloc_nn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_no_alloc_tn"
// cWrapperName: "CasADi__Matrix_int___mul_no_alloc_tn"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___mul_no_alloc_tn(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___mul_no_alloc_tn(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___mul_no_alloc_tn(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int >& x2_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x2);

    CasADi::Matrix< int >::mul_no_alloc_tn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_nt" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_no_alloc_nt"
// cWrapperName: "CasADi__Matrix_int___mul_no_alloc_nt"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___mul_no_alloc_nt(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::Matrix< int >::mul_no_alloc_nt(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___mul_no_alloc_nt(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_int___mul_no_alloc_nt(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int >& x2_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x2);

    CasADi::Matrix< int >::mul_no_alloc_nt(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_tn'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_no_alloc_tn'"
// cWrapperName: "CasADi__Matrix_int___mul_no_alloc_tn_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___mul_no_alloc_tn_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::Matrix< int >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___mul_no_alloc_tn_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_int___mul_no_alloc_tn_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< 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::Matrix< int >::mul_no_alloc_tn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_nn'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::mul_no_alloc_nn'"
// cWrapperName: "CasADi__Matrix_int___mul_no_alloc_nn_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___mul_no_alloc_nn_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::Matrix< int >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_int___mul_no_alloc_nn_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_int___mul_no_alloc_nn_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< 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::Matrix< int >::mul_no_alloc_nn(x0_, x1_, x2_);
}


// ================== Static method: "quad_form" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::quad_form"
// cWrapperName: "CasADi__Matrix_int___quad_form"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___quad_form(CasADi::Matrix< int >* x0, std::vector< int >* x1)"
// call: "CasADi::Matrix< int >::quad_form(x0_, x1_)"
extern "C"
    int CasADi__Matrix_int___quad_form(CasADi::Matrix< int >* x0, std::vector< int >* x1);
int CasADi__Matrix_int___quad_form(CasADi::Matrix< int >* x0, std::vector< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( CasADi::Matrix< int >::quad_form(x0_, x1_) );
}


// ================== Normal method: "trans" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::trans"
// cWrapperName: "CasADi__Matrix_int___trans"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___trans(CasADi::Matrix< int >* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___trans(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___trans(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->trans() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sin"
// cWrapperName: "CasADi__Matrix_int___sin"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___sin(CasADi::Matrix< int >* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___sin(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___sin(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::cos"
// cWrapperName: "CasADi__Matrix_int___cos"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___cos(CasADi::Matrix< int >* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___cos(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___cos(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::tan"
// cWrapperName: "CasADi__Matrix_int___tan"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___tan(CasADi::Matrix< int >* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___tan(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___tan(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arcsin"
// cWrapperName: "CasADi__Matrix_int___arcsin"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arcsin(CasADi::Matrix< int >* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arcsin(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___arcsin(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arccos"
// cWrapperName: "CasADi__Matrix_int___arccos"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arccos(CasADi::Matrix< int >* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arccos(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___arccos(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arctan"
// cWrapperName: "CasADi__Matrix_int___arctan"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arctan(CasADi::Matrix< int >* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arctan(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___arctan(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arctan() );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::exp"
// cWrapperName: "CasADi__Matrix_int___exp"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___exp(CasADi::Matrix< int >* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___exp(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___exp(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::log"
// cWrapperName: "CasADi__Matrix_int___log"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___log(CasADi::Matrix< int >* obj)"
// call: "obj->log()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___log(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___log(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->log() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sqrt"
// cWrapperName: "CasADi__Matrix_int___sqrt"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___sqrt(CasADi::Matrix< int >* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___sqrt(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___sqrt(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->sqrt() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::floor"
// cWrapperName: "CasADi__Matrix_int___floor"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___floor(CasADi::Matrix< int >* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___floor(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___floor(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::ceil"
// cWrapperName: "CasADi__Matrix_int___ceil"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___ceil(CasADi::Matrix< int >* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___ceil(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___ceil(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->ceil() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::fabs"
// cWrapperName: "CasADi__Matrix_int___fabs"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___fabs(CasADi::Matrix< int >* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___fabs(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___fabs(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->fabs() );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sign"
// cWrapperName: "CasADi__Matrix_int___sign"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___sign(CasADi::Matrix< int >* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___sign(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___sign(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->sign() );
}


// ================== Normal method: "__copysign__" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::__copysign__"
// cWrapperName: "CasADi__Matrix_int_____copysign__"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int_____copysign__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__copysign__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int_____copysign__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int_____copysign__(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__copysign__(x0_) );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::erfinv"
// cWrapperName: "CasADi__Matrix_int___erfinv"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___erfinv(CasADi::Matrix< int >* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___erfinv(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___erfinv(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->erfinv() );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::fmin"
// cWrapperName: "CasADi__Matrix_int___fmin"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___fmin(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___fmin(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___fmin(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::fmax"
// cWrapperName: "CasADi__Matrix_int___fmax"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___fmax(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___fmax(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___fmax(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->fmax(x0_) );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::erf"
// cWrapperName: "CasADi__Matrix_int___erf"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___erf(CasADi::Matrix< int >* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___erf(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___erf(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->erf() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sinh"
// cWrapperName: "CasADi__Matrix_int___sinh"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___sinh(CasADi::Matrix< int >* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___sinh(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___sinh(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::cosh"
// cWrapperName: "CasADi__Matrix_int___cosh"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___cosh(CasADi::Matrix< int >* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___cosh(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___cosh(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::tanh"
// cWrapperName: "CasADi__Matrix_int___tanh"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___tanh(CasADi::Matrix< int >* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___tanh(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___tanh(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arcsinh"
// cWrapperName: "CasADi__Matrix_int___arcsinh"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arcsinh(CasADi::Matrix< int >* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arcsinh(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___arcsinh(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arccosh"
// cWrapperName: "CasADi__Matrix_int___arccosh"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arccosh(CasADi::Matrix< int >* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arccosh(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___arccosh(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arctanh"
// cWrapperName: "CasADi__Matrix_int___arctanh"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arctanh(CasADi::Matrix< int >* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arctanh(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___arctanh(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arctanh() );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::arctan2"
// cWrapperName: "CasADi__Matrix_int___arctan2"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___arctan2(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___arctan2(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___arctan2(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->arctan2(x0_) );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::log10"
// cWrapperName: "CasADi__Matrix_int___log10"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___log10(CasADi::Matrix< int >* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___log10(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___log10(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->log10() );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::printme"
// cWrapperName: "CasADi__Matrix_int___printme"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___printme(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___printme(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___printme(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->printme(x0_) );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::logic_not"
// cWrapperName: "CasADi__Matrix_int___logic_not"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___logic_not(CasADi::Matrix< int >* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___logic_not(CasADi::Matrix< int >* obj);
CasADi::Matrix< int >* CasADi__Matrix_int___logic_not(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->logic_not() );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::logic_and"
// cWrapperName: "CasADi__Matrix_int___logic_and"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___logic_and(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___logic_and(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___logic_and(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::logic_or"
// cWrapperName: "CasADi__Matrix_int___logic_or"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___logic_or(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___logic_or(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___logic_or(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::if_else_zero"
// cWrapperName: "CasADi__Matrix_int___if_else_zero"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___if_else_zero(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___if_else_zero(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___if_else_zero(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->if_else_zero(x0_) );
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setMaxNumCallsInPrint"
// cWrapperName: "CasADi__Matrix_int___setMaxNumCallsInPrint"
// protoArgs: "(long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setMaxNumCallsInPrint(long x0)"
// call: "CasADi::Matrix< int >::setMaxNumCallsInPrint(x0_)"
extern "C"
    void CasADi__Matrix_int___setMaxNumCallsInPrint(long x0);
void CasADi__Matrix_int___setMaxNumCallsInPrint(long x0){
    long x0_ = Marshaling<long,long>::marshal(x0);

    CasADi::Matrix< int >::setMaxNumCallsInPrint(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setMaxNumCallsInPrint'"
// cWrapperName: "CasADi__Matrix_int___setMaxNumCallsInPrint_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setMaxNumCallsInPrint_TIC()"
// call: "CasADi::Matrix< int >::setMaxNumCallsInPrint()"
extern "C"
    void CasADi__Matrix_int___setMaxNumCallsInPrint_TIC();
void CasADi__Matrix_int___setMaxNumCallsInPrint_TIC(){

    CasADi::Matrix< int >::setMaxNumCallsInPrint();
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::getMaxNumCallsInPrint"
// cWrapperName: "CasADi__Matrix_int___getMaxNumCallsInPrint"
// protoArgs: "()"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long CasADi__Matrix_int___getMaxNumCallsInPrint()"
// call: "CasADi::Matrix< int >::getMaxNumCallsInPrint()"
extern "C"
    long CasADi__Matrix_int___getMaxNumCallsInPrint();
long CasADi__Matrix_int___getMaxNumCallsInPrint(){

    return WrapReturn< long, long >::wrapReturn( CasADi::Matrix< int >::getMaxNumCallsInPrint() );
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setEqualityCheckingDepth"
// cWrapperName: "CasADi__Matrix_int___setEqualityCheckingDepth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setEqualityCheckingDepth(int x0)"
// call: "CasADi::Matrix< int >::setEqualityCheckingDepth(x0_)"
extern "C"
    void CasADi__Matrix_int___setEqualityCheckingDepth(int x0);
void CasADi__Matrix_int___setEqualityCheckingDepth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< int >::setEqualityCheckingDepth(x0_);
}


// ================== Static method: "setEqualityCheckingDepth'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setEqualityCheckingDepth'"
// cWrapperName: "CasADi__Matrix_int___setEqualityCheckingDepth_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setEqualityCheckingDepth_TIC()"
// call: "CasADi::Matrix< int >::setEqualityCheckingDepth()"
extern "C"
    void CasADi__Matrix_int___setEqualityCheckingDepth_TIC();
void CasADi__Matrix_int___setEqualityCheckingDepth_TIC(){

    CasADi::Matrix< int >::setEqualityCheckingDepth();
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::getEqualityCheckingDepth"
// cWrapperName: "CasADi__Matrix_int___getEqualityCheckingDepth"
// protoArgs: "()"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___getEqualityCheckingDepth()"
// call: "CasADi::Matrix< int >::getEqualityCheckingDepth()"
extern "C"
    int CasADi__Matrix_int___getEqualityCheckingDepth();
int CasADi__Matrix_int___getEqualityCheckingDepth(){

    return WrapReturn< int, int >::wrapReturn( CasADi::Matrix< int >::getEqualityCheckingDepth() );
}


// ================== Static method: "className" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::className"
// cWrapperName: "CasADi__Matrix_int___className"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Matrix_int___className()"
// call: "CasADi::Matrix< int >::className()"
extern "C"
    std::string* CasADi__Matrix_int___className();
std::string* CasADi__Matrix_int___className(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::Matrix< int >::className() );
}


// ================== Normal method: "printScalar'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::printScalar'"
// cWrapperName: "CasADi__Matrix_int___printScalar_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___printScalar_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->printScalar()"
extern "C"
    void CasADi__Matrix_int___printScalar_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___printScalar_TIC(CasADi::Matrix< int >* obj){

    obj->printScalar();
}


// ================== Normal method: "printVector'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::printVector'"
// cWrapperName: "CasADi__Matrix_int___printVector_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___printVector_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->printVector()"
extern "C"
    void CasADi__Matrix_int___printVector_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___printVector_TIC(CasADi::Matrix< int >* obj){

    obj->printVector();
}


// ================== Normal method: "printDense'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::printDense'"
// cWrapperName: "CasADi__Matrix_int___printDense_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___printDense_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->printDense()"
extern "C"
    void CasADi__Matrix_int___printDense_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___printDense_TIC(CasADi::Matrix< int >* obj){

    obj->printDense();
}


// ================== Normal method: "printSparse'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::printSparse'"
// cWrapperName: "CasADi__Matrix_int___printSparse_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___printSparse_TIC(CasADi::Matrix< int >* obj)"
// call: "obj->printSparse()"
extern "C"
    void CasADi__Matrix_int___printSparse_TIC(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___printSparse_TIC(CasADi::Matrix< int >* obj){

    obj->printSparse();
}


// ================== Normal method: "row" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::row"
// cWrapperName: "CasADi__Matrix_int___row"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___row(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->row(x0_)"
extern "C"
    int CasADi__Matrix_int___row(CasADi::Matrix< int >* obj, int x0);
int CasADi__Matrix_int___row(CasADi::Matrix< int >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->row(x0_) );
}


// ================== Normal method: "colind" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::colind"
// cWrapperName: "CasADi__Matrix_int___colind"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___colind(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->colind(x0_)"
extern "C"
    int CasADi__Matrix_int___colind(CasADi::Matrix< int >* obj, int x0);
int CasADi__Matrix_int___colind(CasADi::Matrix< int >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->colind(x0_) );
}


// ================== Normal method: "clear" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::clear"
// cWrapperName: "CasADi__Matrix_int___clear"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___clear(CasADi::Matrix< int >* obj)"
// call: "obj->clear()"
extern "C"
    void CasADi__Matrix_int___clear(CasADi::Matrix< int >* obj);
void CasADi__Matrix_int___clear(CasADi::Matrix< int >* obj){

    obj->clear();
}


// ================== Normal method: "resize" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::resize"
// cWrapperName: "CasADi__Matrix_int___resize"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___resize(CasADi::Matrix< int >* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___resize(CasADi::Matrix< int >* obj, int x0, int x1);
void CasADi__Matrix_int___resize(CasADi::Matrix< int >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
}


// ================== Normal method: "reserve" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::reserve"
// cWrapperName: "CasADi__Matrix_int___reserve"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___reserve(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->reserve(x0_)"
extern "C"
    void CasADi__Matrix_int___reserve(CasADi::Matrix< int >* obj, int x0);
void CasADi__Matrix_int___reserve(CasADi::Matrix< int >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->reserve(x0_);
}


// ================== Normal method: "reserve'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::reserve'"
// cWrapperName: "CasADi__Matrix_int___reserve_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___reserve_TIC(CasADi::Matrix< int >* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___reserve_TIC(CasADi::Matrix< int >* obj, int x0, int x1);
void CasADi__Matrix_int___reserve_TIC(CasADi::Matrix< int >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
}


// ================== Normal method: "erase" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::erase"
// cWrapperName: "CasADi__Matrix_int___erase"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___erase(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___erase(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Matrix_int___erase(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "remove" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::remove"
// cWrapperName: "CasADi__Matrix_int___remove"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___remove(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->remove(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___remove(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Matrix_int___remove(CasADi::Matrix< int >* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "enlarge" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::enlarge"
// cWrapperName: "CasADi__Matrix_int___enlarge"
// protoArgs: "(CasADi::Matrix< int >* 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__Matrix_int___enlarge(CasADi::Matrix< int >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Matrix_int___enlarge(CasADi::Matrix< int >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void CasADi__Matrix_int___enlarge(CasADi::Matrix< int >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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_);
}


// ================== Normal method: "data" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::data"
// cWrapperName: "CasADi__Matrix_int___data"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__Matrix_int___data(CasADi::Matrix< int >* obj)"
// call: "obj->data()"
extern "C"
    std::vector< int >* CasADi__Matrix_int___data(CasADi::Matrix< int >* obj);
std::vector< int >* CasADi__Matrix_int___data(CasADi::Matrix< int >* obj){

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->data() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::sparsityRef"
// cWrapperName: "CasADi__Matrix_int___sparsityRef"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Matrix_int___sparsityRef(CasADi::Matrix< int >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__Matrix_int___sparsityRef(CasADi::Matrix< int >* obj);
CasADi::Sparsity* CasADi__Matrix_int___sparsityRef(CasADi::Matrix< int >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Normal method: "set" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::set"
// cWrapperName: "CasADi__Matrix_int___set"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___set(CasADi::Matrix< int >* obj, int x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___set(CasADi::Matrix< int >* obj, int x0, CasADi::SparsityType x1);
void CasADi__Matrix_int___set(CasADi::Matrix< int >* obj, int x0, CasADi::SparsityType x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::set'"
// cWrapperName: "CasADi__Matrix_int___set_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___set_TIC(CasADi::Matrix< int >* obj, int x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_int___set_TIC(CasADi::Matrix< int >* obj, int x0);
void CasADi__Matrix_int___set_TIC(CasADi::Matrix< int >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::get"
// cWrapperName: "CasADi__Matrix_int___get"
// protoArgs: "(CasADi::Matrix< int >* obj, int* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___get(CasADi::Matrix< int >* obj, int* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___get(CasADi::Matrix< int >* obj, int* x0, CasADi::SparsityType x1);
void CasADi__Matrix_int___get(CasADi::Matrix< int >* obj, int* x0, CasADi::SparsityType x1){
    int& x0_ = Marshaling<int&,int*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::get'"
// cWrapperName: "CasADi__Matrix_int___get_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, int* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___get_TIC(CasADi::Matrix< int >* obj, int* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_int___get_TIC(CasADi::Matrix< int >* obj, int* x0);
void CasADi__Matrix_int___get_TIC(CasADi::Matrix< int >* obj, int* x0){
    int& x0_ = Marshaling<int&,int*>::marshal(x0);

    obj->get(x0_);
}


// ================== Normal method: "set''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::set''"
// cWrapperName: "CasADi__Matrix_int___set_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___set_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___set_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_int___set_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::set'''"
// cWrapperName: "CasADi__Matrix_int___set_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___set_TIC_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_int___set_TIC_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0);
void CasADi__Matrix_int___set_TIC_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::get''"
// cWrapperName: "CasADi__Matrix_int___get_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___get_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___get_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_int___get_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0, CasADi::SparsityType x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::get'''"
// cWrapperName: "CasADi__Matrix_int___get_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___get_TIC_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_int___get_TIC_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0);
void CasADi__Matrix_int___get_TIC_TIC_TIC(CasADi::Matrix< int >* obj, std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    obj->get(x0_);
}


// ================== Normal method: "set''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::set''''"
// cWrapperName: "CasADi__Matrix_int___set_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___set_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___set_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_int___set_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::set'''''"
// cWrapperName: "CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
void CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::get''''"
// cWrapperName: "CasADi__Matrix_int___get_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___get_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_int___get_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_int___get_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0, CasADi::SparsityType x1){
    CasADi::Matrix< int >& x0_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::get'''''"
// cWrapperName: "CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
void CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int >& x0_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x0);

    obj->get(x0_);
}


// ================== Static method: "triplet" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::triplet"
// cWrapperName: "CasADi__Matrix_int___triplet"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::Matrix< int >::triplet(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
CasADi::Matrix< int >* CasADi__Matrix_int___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    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);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::triplet(x0_, x1_, x2_) );
}


// ================== Static method: "triplet'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::triplet'"
// cWrapperName: "CasADi__Matrix_int___triplet_TIC"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4)"
// call: "CasADi::Matrix< int >::triplet(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4);
CasADi::Matrix< int >* CasADi__Matrix_int___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3, int x4){
    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);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::triplet(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::inf"
// cWrapperName: "CasADi__Matrix_int___inf"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___inf(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< int >::inf(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___inf(CasADi::Sparsity* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___inf(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::inf(x0_) );
}


// ================== Static method: "inf'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::inf'"
// cWrapperName: "CasADi__Matrix_int___inf_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC(int x0, int x1)"
// call: "CasADi::Matrix< int >::inf(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC(int x0, int x1);
CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::inf(x0_, x1_) );
}


// ================== Static method: "inf''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::inf''"
// cWrapperName: "CasADi__Matrix_int___inf_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC_TIC(int x0)"
// call: "CasADi::Matrix< int >::inf(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC_TIC(int x0);
CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::inf(x0_) );
}


// ================== Static method: "inf'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::inf'''"
// cWrapperName: "CasADi__Matrix_int___inf_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC_TIC_TIC()"
// call: "CasADi::Matrix< int >::inf()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC_TIC_TIC();
CasADi::Matrix< int >* CasADi__Matrix_int___inf_TIC_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nan"
// cWrapperName: "CasADi__Matrix_int___nan"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___nan(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< int >::nan(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___nan(CasADi::Sparsity* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___nan(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::nan(x0_) );
}


// ================== Static method: "nan'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nan'"
// cWrapperName: "CasADi__Matrix_int___nan_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC(int x0, int x1)"
// call: "CasADi::Matrix< int >::nan(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC(int x0, int x1);
CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::nan(x0_, x1_) );
}


// ================== Static method: "nan''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nan''"
// cWrapperName: "CasADi__Matrix_int___nan_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC_TIC(int x0)"
// call: "CasADi::Matrix< int >::nan(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC_TIC(int x0);
CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::nan(x0_) );
}


// ================== Static method: "nan'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::nan'''"
// cWrapperName: "CasADi__Matrix_int___nan_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC_TIC_TIC()"
// call: "CasADi::Matrix< int >::nan()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC_TIC_TIC();
CasADi::Matrix< int >* CasADi__Matrix_int___nan_TIC_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::repmat"
// cWrapperName: "CasADi__Matrix_int___repmat"
// protoArgs: "(int const * x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___repmat(int const * x0, CasADi::Sparsity* x1)"
// call: "CasADi::Matrix< int >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___repmat(int const * x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__Matrix_int___repmat(int const * x0, CasADi::Sparsity* x1){
    int const & x0_ = Marshaling<int const &,int const *>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::repmat(x0_, x1_) );
}


// ================== Static method: "repmat'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::repmat'"
// cWrapperName: "CasADi__Matrix_int___repmat_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::Matrix< int >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::repmat(x0_, x1_) );
}


// ================== Static method: "repmat''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::repmat''"
// cWrapperName: "CasADi__Matrix_int___repmat_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC_TIC(CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "CasADi::Matrix< int >::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC_TIC(CasADi::Matrix< int >* x0, int x1, int x2);
CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC_TIC(CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::repmat(x0_, x1_, x2_) );
}


// ================== Static method: "repmat'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::repmat'''"
// cWrapperName: "CasADi__Matrix_int___repmat_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC_TIC_TIC(CasADi::Matrix< int >* x0, int x1)"
// call: "CasADi::Matrix< int >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC_TIC_TIC(CasADi::Matrix< int >* x0, int x1);
CasADi::Matrix< int >* CasADi__Matrix_int___repmat_TIC_TIC_TIC(CasADi::Matrix< int >* x0, int x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::repmat(x0_, x1_) );
}


// ================== Static method: "eye" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::eye"
// cWrapperName: "CasADi__Matrix_int___eye"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___eye(int x0)"
// call: "CasADi::Matrix< int >::eye(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___eye(int x0);
CasADi::Matrix< int >* CasADi__Matrix_int___eye(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >::eye(x0_) );
}


// ================== Normal method: "isRegular" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isRegular"
// cWrapperName: "CasADi__Matrix_int___isRegular"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isRegular(CasADi::Matrix< int >* obj)"
// call: "obj->isRegular()"
extern "C"
    int CasADi__Matrix_int___isRegular(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isRegular(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isRegular() );
}


// ================== Normal method: "isSmooth" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isSmooth"
// cWrapperName: "CasADi__Matrix_int___isSmooth"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isSmooth(CasADi::Matrix< int >* obj)"
// call: "obj->isSmooth()"
extern "C"
    int CasADi__Matrix_int___isSmooth(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isSmooth(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSmooth() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isSymbolic"
// cWrapperName: "CasADi__Matrix_int___isSymbolic"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isSymbolic(CasADi::Matrix< int >* obj)"
// call: "obj->isSymbolic()"
extern "C"
    int CasADi__Matrix_int___isSymbolic(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isSymbolic(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolic() );
}


// ================== Normal method: "isSymbolicSparse" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isSymbolicSparse"
// cWrapperName: "CasADi__Matrix_int___isSymbolicSparse"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isSymbolicSparse(CasADi::Matrix< int >* obj)"
// call: "obj->isSymbolicSparse()"
extern "C"
    int CasADi__Matrix_int___isSymbolicSparse(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isSymbolicSparse(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolicSparse() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isConstant"
// cWrapperName: "CasADi__Matrix_int___isConstant"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isConstant(CasADi::Matrix< int >* obj)"
// call: "obj->isConstant()"
extern "C"
    int CasADi__Matrix_int___isConstant(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isConstant(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isConstant() );
}


// ================== Normal method: "isInteger" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isInteger"
// cWrapperName: "CasADi__Matrix_int___isInteger"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isInteger(CasADi::Matrix< int >* obj)"
// call: "obj->isInteger()"
extern "C"
    int CasADi__Matrix_int___isInteger(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isInteger(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInteger() );
}


// ================== Normal method: "isZero" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isZero"
// cWrapperName: "CasADi__Matrix_int___isZero"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isZero(CasADi::Matrix< int >* obj)"
// call: "obj->isZero()"
extern "C"
    int CasADi__Matrix_int___isZero(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isZero(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isZero() );
}


// ================== Normal method: "isOne" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isOne"
// cWrapperName: "CasADi__Matrix_int___isOne"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isOne(CasADi::Matrix< int >* obj)"
// call: "obj->isOne()"
extern "C"
    int CasADi__Matrix_int___isOne(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isOne(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isOne() );
}


// ================== Normal method: "isMinusOne" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isMinusOne"
// cWrapperName: "CasADi__Matrix_int___isMinusOne"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isMinusOne(CasADi::Matrix< int >* obj)"
// call: "obj->isMinusOne()"
extern "C"
    int CasADi__Matrix_int___isMinusOne(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isMinusOne(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMinusOne() );
}


// ================== Normal method: "isIdentity" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isIdentity"
// cWrapperName: "CasADi__Matrix_int___isIdentity"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isIdentity(CasADi::Matrix< int >* obj)"
// call: "obj->isIdentity()"
extern "C"
    int CasADi__Matrix_int___isIdentity(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___isIdentity(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isIdentity() );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::isEqual"
// cWrapperName: "CasADi__Matrix_int___isEqual"
// protoArgs: "(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___isEqual(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    int CasADi__Matrix_int___isEqual(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0);
int CasADi__Matrix_int___isEqual(CasADi::Matrix< int >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_) );
}


// ================== Normal method: "hasNonStructuralZeros" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::hasNonStructuralZeros"
// cWrapperName: "CasADi__Matrix_int___hasNonStructuralZeros"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_int___hasNonStructuralZeros(CasADi::Matrix< int >* obj)"
// call: "obj->hasNonStructuralZeros()"
extern "C"
    int CasADi__Matrix_int___hasNonStructuralZeros(CasADi::Matrix< int >* obj);
int CasADi__Matrix_int___hasNonStructuralZeros(CasADi::Matrix< int >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->hasNonStructuralZeros() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::getValue"
// cWrapperName: "CasADi__Matrix_int___getValue"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_int___getValue(CasADi::Matrix< int >* obj)"
// call: "obj->getValue()"
extern "C"
    double CasADi__Matrix_int___getValue(CasADi::Matrix< int >* obj);
double CasADi__Matrix_int___getValue(CasADi::Matrix< int >* obj){

    return WrapReturn< double, double >::wrapReturn( obj->getValue() );
}


// ================== Normal method: "getName" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::getName"
// cWrapperName: "CasADi__Matrix_int___getName"
// protoArgs: "(CasADi::Matrix< int >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Matrix_int___getName(CasADi::Matrix< int >* obj)"
// call: "obj->getName()"
extern "C"
    std::string* CasADi__Matrix_int___getName(CasADi::Matrix< int >* obj);
std::string* CasADi__Matrix_int___getName(CasADi::Matrix< int >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getName() );
}


// ================== Static method: "setPrecision" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setPrecision"
// cWrapperName: "CasADi__Matrix_int___setPrecision"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setPrecision(int x0)"
// call: "CasADi::Matrix< int >::setPrecision(x0_)"
extern "C"
    void CasADi__Matrix_int___setPrecision(int x0);
void CasADi__Matrix_int___setPrecision(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< int >::setPrecision(x0_);
}


// ================== Static method: "setWidth" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setWidth"
// cWrapperName: "CasADi__Matrix_int___setWidth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setWidth(int x0)"
// call: "CasADi::Matrix< int >::setWidth(x0_)"
extern "C"
    void CasADi__Matrix_int___setWidth(int x0);
void CasADi__Matrix_int___setWidth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< int >::setWidth(x0_);
}


// ================== Static method: "setScientific" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >::setScientific"
// cWrapperName: "CasADi__Matrix_int___setScientific"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_int___setScientific(int x0)"
// call: "CasADi::Matrix< int >::setScientific(x0_)"
extern "C"
    void CasADi__Matrix_int___setScientific(int x0);
void CasADi__Matrix_int___setScientific(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::Matrix< int >::setScientific(x0_);
}


// ================== Constructor method: "IMatrix" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix()"
// call: "CasADi::Matrix< int >()"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix();
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix(){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >() );
}


// ================== Constructor method: "IMatrix'" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::Matrix< int >(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_) );
}


// ================== Constructor method: "IMatrix''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC"
// protoArgs: "(std::vector< std::vector< int >* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC(std::vector< std::vector< int >* >* x0)"
// call: "CasADi::Matrix< int >(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC(std::vector< std::vector< int >* >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC(std::vector< std::vector< int >* >* x0){
    std::vector< std::vector< int > > x0_ = Marshaling<std::vector< std::vector< int > >,std::vector< std::vector< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_) );
}


// ================== Constructor method: "IMatrix'''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int const * x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC(CasADi::Sparsity* x0, int const * x1)"
// call: "CasADi::Matrix< int >(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC(CasADi::Sparsity* x0, int const * x1);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC(CasADi::Sparsity* x0, int const * x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_, x1_) );
}


// ================== Constructor method: "IMatrix''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< int >(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_) );
}


// ================== Constructor method: "IMatrix'''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1)"
// call: "CasADi::Matrix< int >(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_, x1_) );
}


// ================== Constructor method: "IMatrix''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC(double x0)"
// call: "CasADi::Matrix< int >(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC(double x0);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_) );
}


// ================== Constructor method: "IMatrix'''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::Matrix< int >(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_) );
}


// ================== Constructor method: "IMatrix''''''''" ===============
// class: "CasADi::Matrix< int >"
// cppName: "CasADi::Matrix< int >"
// cWrapperName: "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2)"
// call: "CasADi::Matrix< int >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2);
CasADi::Matrix< int >* CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::Matrix< int >(x0_, x1_, x2_) );
}


// ================== delete CasadiClass SXElement===============
// classType: CasadiClass SXElement
extern "C"
    void delete_CasADi__SXElement(CasADi::SXElement* obj);
void delete_CasADi__SXElement(CasADi::SXElement* obj){
    delete obj;
}

// ================== Static method: "sym" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::sym"
// cWrapperName: "CasADi__SXElement__sym"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__sym(std::string* x0)"
// call: "CasADi::SXElement::sym(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__sym(std::string* x0);
CasADi::SXElement* CasADi__SXElement__sym(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::SXElement::sym(x0_) );
}


// ================== Static method: "binary" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::binary"
// cWrapperName: "CasADi__SXElement__binary"
// protoArgs: "(int x0, CasADi::SXElement* x1, CasADi::SXElement* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__binary(int x0, CasADi::SXElement* x1, CasADi::SXElement* x2)"
// call: "CasADi::SXElement::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__binary(int x0, CasADi::SXElement* x1, CasADi::SXElement* x2);
CasADi::SXElement* CasADi__SXElement__binary(int x0, CasADi::SXElement* x1, CasADi::SXElement* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);
    CasADi::SXElement const & x2_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x2);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::SXElement::binary(x0_, x1_, x2_) );
}


// ================== Static method: "unary" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::unary"
// cWrapperName: "CasADi__SXElement__unary"
// protoArgs: "(int x0, CasADi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__unary(int x0, CasADi::SXElement* x1)"
// call: "CasADi::SXElement::unary(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__unary(int x0, CasADi::SXElement* x1);
CasADi::SXElement* CasADi__SXElement__unary(int x0, CasADi::SXElement* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::SXElement::unary(x0_, x1_) );
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__nonzero__"
// cWrapperName: "CasADi__SXElement____nonzero__"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement____nonzero__(CasADi::SXElement* obj)"
// call: "obj->__nonzero__()"
extern "C"
    int CasADi__SXElement____nonzero__(CasADi::SXElement* obj);
int CasADi__SXElement____nonzero__(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->__nonzero__() );
}


// ================== Normal method: "isLeaf" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isLeaf"
// cWrapperName: "CasADi__SXElement__isLeaf"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isLeaf(CasADi::SXElement* obj)"
// call: "obj->isLeaf()"
extern "C"
    int CasADi__SXElement__isLeaf(CasADi::SXElement* obj);
int CasADi__SXElement__isLeaf(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isLeaf() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isConstant"
// cWrapperName: "CasADi__SXElement__isConstant"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isConstant(CasADi::SXElement* obj)"
// call: "obj->isConstant()"
extern "C"
    int CasADi__SXElement__isConstant(CasADi::SXElement* obj);
int CasADi__SXElement__isConstant(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isConstant() );
}


// ================== Normal method: "isInteger" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isInteger"
// cWrapperName: "CasADi__SXElement__isInteger"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isInteger(CasADi::SXElement* obj)"
// call: "obj->isInteger()"
extern "C"
    int CasADi__SXElement__isInteger(CasADi::SXElement* obj);
int CasADi__SXElement__isInteger(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInteger() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isSymbolic"
// cWrapperName: "CasADi__SXElement__isSymbolic"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isSymbolic(CasADi::SXElement* obj)"
// call: "obj->isSymbolic()"
extern "C"
    int CasADi__SXElement__isSymbolic(CasADi::SXElement* obj);
int CasADi__SXElement__isSymbolic(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolic() );
}


// ================== Normal method: "hasDep" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::hasDep"
// cWrapperName: "CasADi__SXElement__hasDep"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__hasDep(CasADi::SXElement* obj)"
// call: "obj->hasDep()"
extern "C"
    int CasADi__SXElement__hasDep(CasADi::SXElement* obj);
int CasADi__SXElement__hasDep(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->hasDep() );
}


// ================== Normal method: "isCommutative" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isCommutative"
// cWrapperName: "CasADi__SXElement__isCommutative"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isCommutative(CasADi::SXElement* obj)"
// call: "obj->isCommutative()"
extern "C"
    int CasADi__SXElement__isCommutative(CasADi::SXElement* obj);
int CasADi__SXElement__isCommutative(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isCommutative() );
}


// ================== Normal method: "isZero" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isZero"
// cWrapperName: "CasADi__SXElement__isZero"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isZero(CasADi::SXElement* obj)"
// call: "obj->isZero()"
extern "C"
    int CasADi__SXElement__isZero(CasADi::SXElement* obj);
int CasADi__SXElement__isZero(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isZero() );
}


// ================== Normal method: "isAlmostZero" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isAlmostZero"
// cWrapperName: "CasADi__SXElement__isAlmostZero"
// protoArgs: "(CasADi::SXElement* obj, double x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isAlmostZero(CasADi::SXElement* obj, double x0)"
// call: "obj->isAlmostZero(x0_)"
extern "C"
    int CasADi__SXElement__isAlmostZero(CasADi::SXElement* obj, double x0);
int CasADi__SXElement__isAlmostZero(CasADi::SXElement* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isAlmostZero(x0_) );
}


// ================== Normal method: "isOne" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isOne"
// cWrapperName: "CasADi__SXElement__isOne"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isOne(CasADi::SXElement* obj)"
// call: "obj->isOne()"
extern "C"
    int CasADi__SXElement__isOne(CasADi::SXElement* obj);
int CasADi__SXElement__isOne(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isOne() );
}


// ================== Normal method: "isMinusOne" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isMinusOne"
// cWrapperName: "CasADi__SXElement__isMinusOne"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isMinusOne(CasADi::SXElement* obj)"
// call: "obj->isMinusOne()"
extern "C"
    int CasADi__SXElement__isMinusOne(CasADi::SXElement* obj);
int CasADi__SXElement__isMinusOne(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMinusOne() );
}


// ================== Normal method: "isNan" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isNan"
// cWrapperName: "CasADi__SXElement__isNan"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isNan(CasADi::SXElement* obj)"
// call: "obj->isNan()"
extern "C"
    int CasADi__SXElement__isNan(CasADi::SXElement* obj);
int CasADi__SXElement__isNan(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isNan() );
}


// ================== Normal method: "isInf" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isInf"
// cWrapperName: "CasADi__SXElement__isInf"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isInf(CasADi::SXElement* obj)"
// call: "obj->isInf()"
extern "C"
    int CasADi__SXElement__isInf(CasADi::SXElement* obj);
int CasADi__SXElement__isInf(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInf() );
}


// ================== Normal method: "isMinusInf" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isMinusInf"
// cWrapperName: "CasADi__SXElement__isMinusInf"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isMinusInf(CasADi::SXElement* obj)"
// call: "obj->isMinusInf()"
extern "C"
    int CasADi__SXElement__isMinusInf(CasADi::SXElement* obj);
int CasADi__SXElement__isMinusInf(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMinusInf() );
}


// ================== Normal method: "getOp" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getOp"
// cWrapperName: "CasADi__SXElement__getOp"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__getOp(CasADi::SXElement* obj)"
// call: "obj->getOp()"
extern "C"
    int CasADi__SXElement__getOp(CasADi::SXElement* obj);
int CasADi__SXElement__getOp(CasADi::SXElement* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getOp() );
}


// ================== Normal method: "isOp" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isOp"
// cWrapperName: "CasADi__SXElement__isOp"
// protoArgs: "(CasADi::SXElement* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isOp(CasADi::SXElement* obj, int x0)"
// call: "obj->isOp(x0_)"
extern "C"
    int CasADi__SXElement__isOp(CasADi::SXElement* obj, int x0);
int CasADi__SXElement__isOp(CasADi::SXElement* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isOp(x0_) );
}


// ================== Normal method: "isRegular" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isRegular"
// cWrapperName: "CasADi__SXElement__isRegular"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isRegular(CasADi::SXElement* obj)"
// call: "obj->isRegular()"
extern "C"
    int CasADi__SXElement__isRegular(CasADi::SXElement* obj);
int CasADi__SXElement__isRegular(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isRegular() );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isEqual"
// cWrapperName: "CasADi__SXElement__isEqual"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isEqual(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1)"
// call: "obj->isEqual(x0_, x1_)"
extern "C"
    int CasADi__SXElement__isEqual(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1);
int CasADi__SXElement__isEqual(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_, x1_) );
}


// ================== Normal method: "isEqual'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isEqual'"
// cWrapperName: "CasADi__SXElement__isEqual_TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isEqual_TIC(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    int CasADi__SXElement__isEqual_TIC(CasADi::SXElement* obj, CasADi::SXElement* x0);
int CasADi__SXElement__isEqual_TIC(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_) );
}


// ================== Normal method: "isNonNegative" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isNonNegative"
// cWrapperName: "CasADi__SXElement__isNonNegative"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isNonNegative(CasADi::SXElement* obj)"
// call: "obj->isNonNegative()"
extern "C"
    int CasADi__SXElement__isNonNegative(CasADi::SXElement* obj);
int CasADi__SXElement__isNonNegative(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isNonNegative() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getValue"
// cWrapperName: "CasADi__SXElement__getValue"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SXElement__getValue(CasADi::SXElement* obj)"
// call: "obj->getValue()"
extern "C"
    double CasADi__SXElement__getValue(CasADi::SXElement* obj);
double CasADi__SXElement__getValue(CasADi::SXElement* obj){

    return WrapReturn< double, double >::wrapReturn( obj->getValue() );
}


// ================== Normal method: "getIntValue" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getIntValue"
// cWrapperName: "CasADi__SXElement__getIntValue"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__getIntValue(CasADi::SXElement* obj)"
// call: "obj->getIntValue()"
extern "C"
    int CasADi__SXElement__getIntValue(CasADi::SXElement* obj);
int CasADi__SXElement__getIntValue(CasADi::SXElement* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getIntValue() );
}


// ================== Normal method: "getDep" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getDep"
// cWrapperName: "CasADi__SXElement__getDep"
// protoArgs: "(CasADi::SXElement* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__getDep(CasADi::SXElement* obj, int x0)"
// call: "obj->getDep(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__getDep(CasADi::SXElement* obj, int x0);
CasADi::SXElement* CasADi__SXElement__getDep(CasADi::SXElement* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->getDep(x0_) );
}


// ================== Normal method: "getDep'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getDep'"
// cWrapperName: "CasADi__SXElement__getDep_TIC"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__getDep_TIC(CasADi::SXElement* obj)"
// call: "obj->getDep()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__getDep_TIC(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__getDep_TIC(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->getDep() );
}


// ================== Normal method: "isDoubled" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isDoubled"
// cWrapperName: "CasADi__SXElement__isDoubled"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isDoubled(CasADi::SXElement* obj)"
// call: "obj->isDoubled()"
extern "C"
    int CasADi__SXElement__isDoubled(CasADi::SXElement* obj);
int CasADi__SXElement__isDoubled(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDoubled() );
}


// ================== Normal method: "getNdeps" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getNdeps"
// cWrapperName: "CasADi__SXElement__getNdeps"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__getNdeps(CasADi::SXElement* obj)"
// call: "obj->getNdeps()"
extern "C"
    int CasADi__SXElement__getNdeps(CasADi::SXElement* obj);
int CasADi__SXElement__getNdeps(CasADi::SXElement* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNdeps() );
}


// ================== Normal method: "__hash__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__hash__"
// cWrapperName: "CasADi__SXElement____hash__"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long CasADi__SXElement____hash__(CasADi::SXElement* obj)"
// call: "obj->__hash__()"
extern "C"
    long CasADi__SXElement____hash__(CasADi::SXElement* obj);
long CasADi__SXElement____hash__(CasADi::SXElement* obj){

    return WrapReturn< long, long >::wrapReturn( obj->__hash__() );
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::operator -"
// cWrapperName: "CasADi__SXElement__operator_minus"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__operator_minus(CasADi::SXElement* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__operator_minus(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__operator_minus(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->operator -() );
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__add__"
// cWrapperName: "CasADi__SXElement____add__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____add__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____add__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____add__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__sub__"
// cWrapperName: "CasADi__SXElement____sub__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____sub__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____sub__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____sub__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__mul__"
// cWrapperName: "CasADi__SXElement____mul__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____mul__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____mul__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____mul__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__div__"
// cWrapperName: "CasADi__SXElement____div__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____div__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____div__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____div__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__lt__"
// cWrapperName: "CasADi__SXElement____lt__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____lt__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____lt__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____lt__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__le__"
// cWrapperName: "CasADi__SXElement____le__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____le__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____le__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____le__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__eq__"
// cWrapperName: "CasADi__SXElement____eq__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____eq__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____eq__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____eq__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__ne__"
// cWrapperName: "CasADi__SXElement____ne__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____ne__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____ne__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____ne__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__truediv__"
// cWrapperName: "CasADi__SXElement____truediv__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____truediv__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____truediv__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____truediv__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__pow__"
// cWrapperName: "CasADi__SXElement____pow__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____pow__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____pow__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____pow__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__constpow__"
// cWrapperName: "CasADi__SXElement____constpow__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____constpow__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____constpow__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____constpow__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__mrdivide__"
// cWrapperName: "CasADi__SXElement____mrdivide__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____mrdivide__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____mrdivide__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____mrdivide__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__mpower__"
// cWrapperName: "CasADi__SXElement____mpower__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____mpower__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____mpower__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____mpower__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__mpower__(x0_) );
}


// ================== Normal method: "trans" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::trans"
// cWrapperName: "CasADi__SXElement__trans"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__trans(CasADi::SXElement* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__trans(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__trans(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->trans() );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::mul"
// cWrapperName: "CasADi__SXElement__mul"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__mul(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__mul(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__mul(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->mul(x0_) );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::exp"
// cWrapperName: "CasADi__SXElement__exp"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__exp(CasADi::SXElement* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__exp(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__exp(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::log"
// cWrapperName: "CasADi__SXElement__log"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__log(CasADi::SXElement* obj)"
// call: "obj->log()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__log(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__log(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->log() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::sqrt"
// cWrapperName: "CasADi__SXElement__sqrt"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__sqrt(CasADi::SXElement* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__sqrt(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__sqrt(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->sqrt() );
}


// ================== Normal method: "sq" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::sq"
// cWrapperName: "CasADi__SXElement__sq"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__sq(CasADi::SXElement* obj)"
// call: "obj->sq()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__sq(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__sq(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->sq() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::sin"
// cWrapperName: "CasADi__SXElement__sin"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__sin(CasADi::SXElement* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__sin(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__sin(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::cos"
// cWrapperName: "CasADi__SXElement__cos"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__cos(CasADi::SXElement* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__cos(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__cos(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::tan"
// cWrapperName: "CasADi__SXElement__tan"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__tan(CasADi::SXElement* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__tan(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__tan(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arcsin"
// cWrapperName: "CasADi__SXElement__arcsin"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arcsin(CasADi::SXElement* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arcsin(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__arcsin(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arccos"
// cWrapperName: "CasADi__SXElement__arccos"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arccos(CasADi::SXElement* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arccos(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__arccos(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arctan"
// cWrapperName: "CasADi__SXElement__arctan"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arctan(CasADi::SXElement* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arctan(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__arctan(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arctan() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::floor"
// cWrapperName: "CasADi__SXElement__floor"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__floor(CasADi::SXElement* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__floor(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__floor(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::ceil"
// cWrapperName: "CasADi__SXElement__ceil"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__ceil(CasADi::SXElement* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__ceil(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__ceil(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->ceil() );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::erf"
// cWrapperName: "CasADi__SXElement__erf"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__erf(CasADi::SXElement* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__erf(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__erf(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->erf() );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::erfinv"
// cWrapperName: "CasADi__SXElement__erfinv"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__erfinv(CasADi::SXElement* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__erfinv(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__erfinv(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->erfinv() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::fabs"
// cWrapperName: "CasADi__SXElement__fabs"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__fabs(CasADi::SXElement* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__fabs(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__fabs(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->fabs() );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::fmin"
// cWrapperName: "CasADi__SXElement__fmin"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__fmin(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__fmin(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__fmin(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::fmax"
// cWrapperName: "CasADi__SXElement__fmax"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__fmax(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__fmax(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__fmax(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->fmax(x0_) );
}


// ================== Normal method: "inv" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::inv"
// cWrapperName: "CasADi__SXElement__inv"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__inv(CasADi::SXElement* obj)"
// call: "obj->inv()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__inv(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__inv(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->inv() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::sinh"
// cWrapperName: "CasADi__SXElement__sinh"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__sinh(CasADi::SXElement* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__sinh(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__sinh(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::cosh"
// cWrapperName: "CasADi__SXElement__cosh"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__cosh(CasADi::SXElement* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__cosh(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__cosh(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::tanh"
// cWrapperName: "CasADi__SXElement__tanh"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__tanh(CasADi::SXElement* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__tanh(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__tanh(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arcsinh"
// cWrapperName: "CasADi__SXElement__arcsinh"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arcsinh(CasADi::SXElement* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arcsinh(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__arcsinh(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arccosh"
// cWrapperName: "CasADi__SXElement__arccosh"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arccosh(CasADi::SXElement* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arccosh(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__arccosh(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arctanh"
// cWrapperName: "CasADi__SXElement__arctanh"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arctanh(CasADi::SXElement* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arctanh(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__arctanh(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arctanh() );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arctan2"
// cWrapperName: "CasADi__SXElement__arctan2"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__arctan2(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__arctan2(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__arctan2(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->arctan2(x0_) );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::log10"
// cWrapperName: "CasADi__SXElement__log10"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__log10(CasADi::SXElement* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__log10(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__log10(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->log10() );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::printme"
// cWrapperName: "CasADi__SXElement__printme"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__printme(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__printme(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__printme(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->printme(x0_) );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::sign"
// cWrapperName: "CasADi__SXElement__sign"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__sign(CasADi::SXElement* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__sign(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__sign(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->sign() );
}


// ================== Normal method: "__copysign__" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__copysign__"
// cWrapperName: "CasADi__SXElement____copysign__"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement____copysign__(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->__copysign__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement____copysign__(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement____copysign__(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__copysign__(x0_) );
}


// ================== Normal method: "constpow" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::constpow"
// cWrapperName: "CasADi__SXElement__constpow"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__constpow(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->constpow(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__constpow(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__constpow(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->constpow(x0_) );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::logic_not"
// cWrapperName: "CasADi__SXElement__logic_not"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__logic_not(CasADi::SXElement* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__logic_not(CasADi::SXElement* obj);
CasADi::SXElement* CasADi__SXElement__logic_not(CasADi::SXElement* obj){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->logic_not() );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::logic_and"
// cWrapperName: "CasADi__SXElement__logic_and"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__logic_and(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__logic_and(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__logic_and(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::logic_or"
// cWrapperName: "CasADi__SXElement__logic_or"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__logic_or(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__logic_or(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__logic_or(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::if_else_zero"
// cWrapperName: "CasADi__SXElement__if_else_zero"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__if_else_zero(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__if_else_zero(CasADi::SXElement* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__SXElement__if_else_zero(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->if_else_zero(x0_) );
}


// ================== Normal method: "fmin'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::fmin'"
// cWrapperName: "CasADi__SXElement__fmin_TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__fmin_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__fmin_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__fmin_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->fmin(x0_) );
}


// ================== Normal method: "fmax'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::fmax'"
// cWrapperName: "CasADi__SXElement__fmax_TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__fmax_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__fmax_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__fmax_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->fmax(x0_) );
}


// ================== Normal method: "constpow'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::constpow'"
// cWrapperName: "CasADi__SXElement__constpow_TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__constpow_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->constpow(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__constpow_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__constpow_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->constpow(x0_) );
}


// ================== Normal method: "__copysign__'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::__copysign__'"
// cWrapperName: "CasADi__SXElement____copysign___TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement____copysign___TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__copysign__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement____copysign___TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement____copysign___TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__copysign__(x0_) );
}


// ================== Normal method: "arctan2'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::arctan2'"
// cWrapperName: "CasADi__SXElement__arctan2_TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__arctan2_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__arctan2_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SXElement__arctan2_TIC(CasADi::SXElement* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arctan2(x0_) );
}


// ================== Normal method: "getTemp" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::getTemp"
// cWrapperName: "CasADi__SXElement__getTemp"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__getTemp(CasADi::SXElement* obj)"
// call: "obj->getTemp()"
extern "C"
    int CasADi__SXElement__getTemp(CasADi::SXElement* obj);
int CasADi__SXElement__getTemp(CasADi::SXElement* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getTemp() );
}


// ================== Normal method: "setTemp" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::setTemp"
// cWrapperName: "CasADi__SXElement__setTemp"
// protoArgs: "(CasADi::SXElement* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SXElement__setTemp(CasADi::SXElement* obj, int x0)"
// call: "obj->setTemp(x0_)"
extern "C"
    void CasADi__SXElement__setTemp(CasADi::SXElement* obj, int x0);
void CasADi__SXElement__setTemp(CasADi::SXElement* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setTemp(x0_);
}


// ================== Normal method: "marked" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::marked"
// cWrapperName: "CasADi__SXElement__marked"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__marked(CasADi::SXElement* obj)"
// call: "obj->marked()"
extern "C"
    int CasADi__SXElement__marked(CasADi::SXElement* obj);
int CasADi__SXElement__marked(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->marked() );
}


// ================== Normal method: "mark" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::mark"
// cWrapperName: "CasADi__SXElement__mark"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SXElement__mark(CasADi::SXElement* obj)"
// call: "obj->mark()"
extern "C"
    void CasADi__SXElement__mark(CasADi::SXElement* obj);
void CasADi__SXElement__mark(CasADi::SXElement* obj){

    obj->mark();
}


// ================== Normal method: "assignIfDuplicate" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::assignIfDuplicate"
// cWrapperName: "CasADi__SXElement__assignIfDuplicate"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SXElement__assignIfDuplicate(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1)"
// call: "obj->assignIfDuplicate(x0_, x1_)"
extern "C"
    void CasADi__SXElement__assignIfDuplicate(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1);
void CasADi__SXElement__assignIfDuplicate(CasADi::SXElement* obj, CasADi::SXElement* x0, int x1){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->assignIfDuplicate(x0_, x1_);
}


// ================== Normal method: "assignIfDuplicate'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::assignIfDuplicate'"
// cWrapperName: "CasADi__SXElement__assignIfDuplicate_TIC"
// protoArgs: "(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SXElement__assignIfDuplicate_TIC(CasADi::SXElement* obj, CasADi::SXElement* x0)"
// call: "obj->assignIfDuplicate(x0_)"
extern "C"
    void CasADi__SXElement__assignIfDuplicate_TIC(CasADi::SXElement* obj, CasADi::SXElement* x0);
void CasADi__SXElement__assignIfDuplicate_TIC(CasADi::SXElement* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    obj->assignIfDuplicate(x0_);
}


// ================== Normal method: "isNull" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement::isNull"
// cWrapperName: "CasADi__SXElement__isNull"
// protoArgs: "(CasADi::SXElement* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SXElement__isNull(CasADi::SXElement* obj)"
// call: "obj->isNull()"
extern "C"
    int CasADi__SXElement__isNull(CasADi::SXElement* obj);
int CasADi__SXElement__isNull(CasADi::SXElement* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isNull() );
}


// ================== Constructor method: "SXElement" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement"
// cWrapperName: "CasADi__SXElement__SXElement"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__SXElement()"
// call: "CasADi::SXElement()"
extern "C"
    CasADi::SXElement* CasADi__SXElement__SXElement();
CasADi::SXElement* CasADi__SXElement__SXElement(){

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::SXElement() );
}


// ================== Constructor method: "SXElement'" ===============
// class: "CasADi::SXElement"
// cppName: "CasADi::SXElement"
// cWrapperName: "CasADi__SXElement__SXElement_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__SXElement__SXElement_TIC(double x0)"
// call: "CasADi::SXElement(x0_)"
extern "C"
    CasADi::SXElement* CasADi__SXElement__SXElement_TIC(double x0);
CasADi::SXElement* CasADi__SXElement__SXElement_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::SXElement(x0_) );
}


// ================== delete CasadiClass SCPgen===============
// classType: CasadiClass SCPgen
extern "C"
    void delete_CasADi__SCPgen(CasADi::SCPgen* obj);
void delete_CasADi__SCPgen(CasADi::SCPgen* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SCPgen"
// cppName: "CasADi::SCPgen::checkNode"
// cWrapperName: "CasADi__SCPgen__checkNode"
// protoArgs: "(CasADi::SCPgen* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SCPgen__checkNode(CasADi::SCPgen* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SCPgen__checkNode(CasADi::SCPgen* obj);
int CasADi__SCPgen__checkNode(CasADi::SCPgen* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SCPgen"
// cppName: "CasADi::SCPgen::creator"
// cWrapperName: "CasADi__SCPgen__creator"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__SCPgen__creator(CasADi::Function* x0)"
// call: "CasADi::SCPgen::creator(x0_)"
extern "C"
    CasADi::NLPSolver* CasADi__SCPgen__creator(CasADi::Function* x0);
CasADi::NLPSolver* CasADi__SCPgen__creator(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( CasADi::SCPgen::creator(x0_) );
}


// ================== Constructor method: "SCPgen" ===============
// class: "CasADi::SCPgen"
// cppName: "CasADi::SCPgen"
// cWrapperName: "CasADi__SCPgen__SCPgen"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SCPgen
// cWrapperRetType: "CasADi::SCPgen*"
// proto: "CasADi::SCPgen* CasADi__SCPgen__SCPgen()"
// call: "CasADi::SCPgen()"
extern "C"
    CasADi::SCPgen* CasADi__SCPgen__SCPgen();
CasADi::SCPgen* CasADi__SCPgen__SCPgen(){

    return WrapReturn< CasADi::SCPgen*, CasADi::SCPgen >::wrapReturn( CasADi::SCPgen() );
}


// ================== Constructor method: "SCPgen'" ===============
// class: "CasADi::SCPgen"
// cppName: "CasADi::SCPgen"
// cWrapperName: "CasADi__SCPgen__SCPgen_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass SCPgen
// cWrapperRetType: "CasADi::SCPgen*"
// proto: "CasADi::SCPgen* CasADi__SCPgen__SCPgen_TIC(CasADi::Function* x0)"
// call: "CasADi::SCPgen(x0_)"
extern "C"
    CasADi::SCPgen* CasADi__SCPgen__SCPgen_TIC(CasADi::Function* x0);
CasADi::SCPgen* CasADi__SCPgen__SCPgen_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::SCPgen*, CasADi::SCPgen >::wrapReturn( CasADi::SCPgen(x0_) );
}


// ================== delete CasadiClass NLPImplicitSolver===============
// classType: CasadiClass NLPImplicitSolver
extern "C"
    void delete_CasADi__NLPImplicitSolver(CasADi::NLPImplicitSolver* obj);
void delete_CasADi__NLPImplicitSolver(CasADi::NLPImplicitSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver::checkNode"
// cWrapperName: "CasADi__NLPImplicitSolver__checkNode"
// protoArgs: "(CasADi::NLPImplicitSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__NLPImplicitSolver__checkNode(CasADi::NLPImplicitSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__NLPImplicitSolver__checkNode(CasADi::NLPImplicitSolver* obj);
int CasADi__NLPImplicitSolver__checkNode(CasADi::NLPImplicitSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getNLPSolver" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver::getNLPSolver"
// cWrapperName: "CasADi__NLPImplicitSolver__getNLPSolver"
// protoArgs: "(CasADi::NLPImplicitSolver* obj)"
// args: "()"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__NLPImplicitSolver__getNLPSolver(CasADi::NLPImplicitSolver* obj)"
// call: "obj->getNLPSolver()"
extern "C"
    CasADi::NLPSolver* CasADi__NLPImplicitSolver__getNLPSolver(CasADi::NLPImplicitSolver* obj);
CasADi::NLPSolver* CasADi__NLPImplicitSolver__getNLPSolver(CasADi::NLPImplicitSolver* obj){

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( obj->getNLPSolver() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver::creator"
// cWrapperName: "CasADi__NLPImplicitSolver__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass ImplicitFunction
// cWrapperRetType: "CasADi::ImplicitFunction*"
// proto: "CasADi::ImplicitFunction* CasADi__NLPImplicitSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// call: "CasADi::NLPImplicitSolver::creator(x0_, x1_, x2_)"
extern "C"
    CasADi::ImplicitFunction* CasADi__NLPImplicitSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2);
CasADi::ImplicitFunction* CasADi__NLPImplicitSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::LinearSolver const & x2_ = Marshaling<CasADi::LinearSolver const &,CasADi::LinearSolver*>::marshal(x2);

    return WrapReturn< CasADi::ImplicitFunction*, CasADi::ImplicitFunction >::wrapReturn( CasADi::NLPImplicitSolver::creator(x0_, x1_, x2_) );
}


// ================== Constructor method: "NLPImplicitSolver" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver"
// cWrapperName: "CasADi__NLPImplicitSolver__NLPImplicitSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass NLPImplicitSolver
// cWrapperRetType: "CasADi::NLPImplicitSolver*"
// proto: "CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver()"
// call: "CasADi::NLPImplicitSolver()"
extern "C"
    CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver();
CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver(){

    return WrapReturn< CasADi::NLPImplicitSolver*, CasADi::NLPImplicitSolver >::wrapReturn( CasADi::NLPImplicitSolver() );
}


// ================== Constructor method: "NLPImplicitSolver'" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver"
// cWrapperName: "CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass NLPImplicitSolver
// cWrapperRetType: "CasADi::NLPImplicitSolver*"
// proto: "CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// call: "CasADi::NLPImplicitSolver(x0_, x1_, x2_)"
extern "C"
    CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2);
CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::LinearSolver const & x2_ = Marshaling<CasADi::LinearSolver const &,CasADi::LinearSolver*>::marshal(x2);

    return WrapReturn< CasADi::NLPImplicitSolver*, CasADi::NLPImplicitSolver >::wrapReturn( CasADi::NLPImplicitSolver(x0_, x1_, x2_) );
}


// ================== Constructor method: "NLPImplicitSolver''" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver"
// cWrapperName: "CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass NLPImplicitSolver
// cWrapperRetType: "CasADi::NLPImplicitSolver*"
// proto: "CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::NLPImplicitSolver(x0_, x1_)"
extern "C"
    CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::NLPImplicitSolver*, CasADi::NLPImplicitSolver >::wrapReturn( CasADi::NLPImplicitSolver(x0_, x1_) );
}


// ================== Constructor method: "NLPImplicitSolver'''" ===============
// class: "CasADi::NLPImplicitSolver"
// cppName: "CasADi::NLPImplicitSolver"
// cWrapperName: "CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass NLPImplicitSolver
// cWrapperRetType: "CasADi::NLPImplicitSolver*"
// proto: "CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::NLPImplicitSolver(x0_)"
extern "C"
    CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC_TIC(CasADi::Function* x0);
CasADi::NLPImplicitSolver* CasADi__NLPImplicitSolver__NLPImplicitSolver_TIC_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::NLPImplicitSolver*, CasADi::NLPImplicitSolver >::wrapReturn( CasADi::NLPImplicitSolver(x0_) );
}


// ================== delete CasadiClass ExternalFunction===============
// classType: CasadiClass ExternalFunction
extern "C"
    void delete_CasADi__ExternalFunction(CasADi::ExternalFunction* obj);
void delete_CasADi__ExternalFunction(CasADi::ExternalFunction* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::ExternalFunction"
// cppName: "CasADi::ExternalFunction::checkNode"
// cWrapperName: "CasADi__ExternalFunction__checkNode"
// protoArgs: "(CasADi::ExternalFunction* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj);
int CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "ExternalFunction" ===============
// class: "CasADi::ExternalFunction"
// cppName: "CasADi::ExternalFunction"
// cWrapperName: "CasADi__ExternalFunction__ExternalFunction"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass ExternalFunction
// cWrapperRetType: "CasADi::ExternalFunction*"
// proto: "CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction()"
// call: "CasADi::ExternalFunction()"
extern "C"
    CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction();
CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction(){

    return WrapReturn< CasADi::ExternalFunction*, CasADi::ExternalFunction >::wrapReturn( CasADi::ExternalFunction() );
}


// ================== Constructor method: "ExternalFunction'" ===============
// class: "CasADi::ExternalFunction"
// cppName: "CasADi::ExternalFunction"
// cWrapperName: "CasADi__ExternalFunction__ExternalFunction_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass ExternalFunction
// cWrapperRetType: "CasADi::ExternalFunction*"
// proto: "CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction_TIC(std::string* x0)"
// call: "CasADi::ExternalFunction(x0_)"
extern "C"
    CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction_TIC(std::string* x0);
CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::ExternalFunction*, CasADi::ExternalFunction >::wrapReturn( CasADi::ExternalFunction(x0_) );
}


// ================== delete CasadiClass SimpleIndefDpleSolver===============
// classType: CasadiClass SimpleIndefDpleSolver
extern "C"
    void delete_CasADi__SimpleIndefDpleSolver(CasADi::SimpleIndefDpleSolver* obj);
void delete_CasADi__SimpleIndefDpleSolver(CasADi::SimpleIndefDpleSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SimpleIndefDpleSolver"
// cppName: "CasADi::SimpleIndefDpleSolver::checkNode"
// cWrapperName: "CasADi__SimpleIndefDpleSolver__checkNode"
// protoArgs: "(CasADi::SimpleIndefDpleSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SimpleIndefDpleSolver__checkNode(CasADi::SimpleIndefDpleSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SimpleIndefDpleSolver__checkNode(CasADi::SimpleIndefDpleSolver* obj);
int CasADi__SimpleIndefDpleSolver__checkNode(CasADi::SimpleIndefDpleSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SimpleIndefDpleSolver"
// cppName: "CasADi::SimpleIndefDpleSolver::creator"
// cWrapperName: "CasADi__SimpleIndefDpleSolver__creator"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DpleSolver
// cWrapperRetType: "CasADi::DpleSolver*"
// proto: "CasADi::DpleSolver* CasADi__SimpleIndefDpleSolver__creator(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1)"
// call: "CasADi::SimpleIndefDpleSolver::creator(x0_, x1_)"
extern "C"
    CasADi::DpleSolver* CasADi__SimpleIndefDpleSolver__creator(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1);
CasADi::DpleSolver* CasADi__SimpleIndefDpleSolver__creator(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);
    std::vector< CasADi::Sparsity > x1_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x1);

    return WrapReturn< CasADi::DpleSolver*, CasADi::DpleSolver >::wrapReturn( CasADi::SimpleIndefDpleSolver::creator(x0_, x1_) );
}


// ================== Constructor method: "SimpleIndefDpleSolver" ===============
// class: "CasADi::SimpleIndefDpleSolver"
// cppName: "CasADi::SimpleIndefDpleSolver"
// cWrapperName: "CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SimpleIndefDpleSolver
// cWrapperRetType: "CasADi::SimpleIndefDpleSolver*"
// proto: "CasADi::SimpleIndefDpleSolver* CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver()"
// call: "CasADi::SimpleIndefDpleSolver()"
extern "C"
    CasADi::SimpleIndefDpleSolver* CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver();
CasADi::SimpleIndefDpleSolver* CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver(){

    return WrapReturn< CasADi::SimpleIndefDpleSolver*, CasADi::SimpleIndefDpleSolver >::wrapReturn( CasADi::SimpleIndefDpleSolver() );
}


// ================== Constructor method: "SimpleIndefDpleSolver'" ===============
// class: "CasADi::SimpleIndefDpleSolver"
// cppName: "CasADi::SimpleIndefDpleSolver"
// cWrapperName: "CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver_TIC"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SimpleIndefDpleSolver
// cWrapperRetType: "CasADi::SimpleIndefDpleSolver*"
// proto: "CasADi::SimpleIndefDpleSolver* CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver_TIC(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1)"
// call: "CasADi::SimpleIndefDpleSolver(x0_, x1_)"
extern "C"
    CasADi::SimpleIndefDpleSolver* CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver_TIC(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1);
CasADi::SimpleIndefDpleSolver* CasADi__SimpleIndefDpleSolver__SimpleIndefDpleSolver_TIC(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::Sparsity* >* x1){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);
    std::vector< CasADi::Sparsity > x1_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x1);

    return WrapReturn< CasADi::SimpleIndefDpleSolver*, CasADi::SimpleIndefDpleSolver >::wrapReturn( CasADi::SimpleIndefDpleSolver(x0_, x1_) );
}


// ================== delete CasadiClass DirectCollocation===============
// classType: CasadiClass DirectCollocation
extern "C"
    void delete_CasADi__DirectCollocation(CasADi::DirectCollocation* obj);
void delete_CasADi__DirectCollocation(CasADi::DirectCollocation* obj){
    delete obj;
}

// ================== Normal method: "getGuess" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::getGuess"
// cWrapperName: "CasADi__DirectCollocation__getGuess"
// protoArgs: "(CasADi::DirectCollocation* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectCollocation__getGuess(CasADi::DirectCollocation* obj, std::vector< double >* x0)"
// call: "obj->getGuess(x0_)"
extern "C"
    void CasADi__DirectCollocation__getGuess(CasADi::DirectCollocation* obj, std::vector< double >* x0);
void CasADi__DirectCollocation__getGuess(CasADi::DirectCollocation* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->getGuess(x0_);
}


// ================== Normal method: "getVariableBounds" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::getVariableBounds"
// cWrapperName: "CasADi__DirectCollocation__getVariableBounds"
// protoArgs: "(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectCollocation__getVariableBounds(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1)"
// call: "obj->getVariableBounds(x0_, x1_)"
extern "C"
    void CasADi__DirectCollocation__getVariableBounds(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1);
void CasADi__DirectCollocation__getVariableBounds(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->getVariableBounds(x0_, x1_);
}


// ================== Normal method: "getConstraintBounds" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::getConstraintBounds"
// cWrapperName: "CasADi__DirectCollocation__getConstraintBounds"
// protoArgs: "(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectCollocation__getConstraintBounds(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1)"
// call: "obj->getConstraintBounds(x0_, x1_)"
extern "C"
    void CasADi__DirectCollocation__getConstraintBounds(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1);
void CasADi__DirectCollocation__getConstraintBounds(CasADi::DirectCollocation* obj, std::vector< double >* x0, std::vector< double >* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->getConstraintBounds(x0_, x1_);
}


// ================== Normal method: "setOptimalSolution" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::setOptimalSolution"
// cWrapperName: "CasADi__DirectCollocation__setOptimalSolution"
// protoArgs: "(CasADi::DirectCollocation* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectCollocation__setOptimalSolution(CasADi::DirectCollocation* obj, std::vector< double >* x0)"
// call: "obj->setOptimalSolution(x0_)"
extern "C"
    void CasADi__DirectCollocation__setOptimalSolution(CasADi::DirectCollocation* obj, std::vector< double >* x0);
void CasADi__DirectCollocation__setOptimalSolution(CasADi::DirectCollocation* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setOptimalSolution(x0_);
}


// ================== Normal method: "getNLPSolver" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::getNLPSolver"
// cWrapperName: "CasADi__DirectCollocation__getNLPSolver"
// protoArgs: "(CasADi::DirectCollocation* obj)"
// args: "()"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__DirectCollocation__getNLPSolver(CasADi::DirectCollocation* obj)"
// call: "obj->getNLPSolver()"
extern "C"
    CasADi::NLPSolver* CasADi__DirectCollocation__getNLPSolver(CasADi::DirectCollocation* obj);
CasADi::NLPSolver* CasADi__DirectCollocation__getNLPSolver(CasADi::DirectCollocation* obj){

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( obj->getNLPSolver() );
}


// ================== Normal method: "reportConstraints'" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::reportConstraints'"
// cWrapperName: "CasADi__DirectCollocation__reportConstraints_TIC"
// protoArgs: "(CasADi::DirectCollocation* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectCollocation__reportConstraints_TIC(CasADi::DirectCollocation* obj)"
// call: "obj->reportConstraints()"
extern "C"
    void CasADi__DirectCollocation__reportConstraints_TIC(CasADi::DirectCollocation* obj);
void CasADi__DirectCollocation__reportConstraints_TIC(CasADi::DirectCollocation* obj){

    obj->reportConstraints();
}


// ================== Normal method: "getReportConstraints" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation::getReportConstraints"
// cWrapperName: "CasADi__DirectCollocation__getReportConstraints"
// protoArgs: "(CasADi::DirectCollocation* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__DirectCollocation__getReportConstraints(CasADi::DirectCollocation* obj)"
// call: "obj->getReportConstraints()"
extern "C"
    std::string* CasADi__DirectCollocation__getReportConstraints(CasADi::DirectCollocation* obj);
std::string* CasADi__DirectCollocation__getReportConstraints(CasADi::DirectCollocation* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getReportConstraints() );
}


// ================== Constructor method: "DirectCollocation" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation"
// cWrapperName: "CasADi__DirectCollocation__DirectCollocation"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DirectCollocation
// cWrapperRetType: "CasADi::DirectCollocation*"
// proto: "CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation()"
// call: "CasADi::DirectCollocation()"
extern "C"
    CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation();
CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation(){

    return WrapReturn< CasADi::DirectCollocation*, CasADi::DirectCollocation >::wrapReturn( CasADi::DirectCollocation() );
}


// ================== Constructor method: "DirectCollocation'" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation"
// cWrapperName: "CasADi__DirectCollocation__DirectCollocation_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass DirectCollocation
// cWrapperRetType: "CasADi::DirectCollocation*"
// proto: "CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3)"
// call: "CasADi::DirectCollocation(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3);
CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Function const & x2_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x2);
    CasADi::Function const & x3_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x3);

    return WrapReturn< CasADi::DirectCollocation*, CasADi::DirectCollocation >::wrapReturn( CasADi::DirectCollocation(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "DirectCollocation''" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation"
// cWrapperName: "CasADi__DirectCollocation__DirectCollocation_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DirectCollocation
// cWrapperRetType: "CasADi::DirectCollocation*"
// proto: "CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2)"
// call: "CasADi::DirectCollocation(x0_, x1_, x2_)"
extern "C"
    CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2);
CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Function const & x2_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x2);

    return WrapReturn< CasADi::DirectCollocation*, CasADi::DirectCollocation >::wrapReturn( CasADi::DirectCollocation(x0_, x1_, x2_) );
}


// ================== Constructor method: "DirectCollocation'''" ===============
// class: "CasADi::DirectCollocation"
// cppName: "CasADi::DirectCollocation"
// cWrapperName: "CasADi__DirectCollocation__DirectCollocation_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DirectCollocation
// cWrapperRetType: "CasADi::DirectCollocation*"
// proto: "CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::DirectCollocation(x0_, x1_)"
extern "C"
    CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::DirectCollocation* CasADi__DirectCollocation__DirectCollocation_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::DirectCollocation*, CasADi::DirectCollocation >::wrapReturn( CasADi::DirectCollocation(x0_, x1_) );
}


// ================== delete CasadiClass QPStabilizer===============
// classType: CasadiClass QPStabilizer
extern "C"
    void delete_CasADi__QPStabilizer(CasADi::QPStabilizer* obj);
void delete_CasADi__QPStabilizer(CasADi::QPStabilizer* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::QPStabilizer"
// cppName: "CasADi::QPStabilizer::checkNode"
// cWrapperName: "CasADi__QPStabilizer__checkNode"
// protoArgs: "(CasADi::QPStabilizer* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__QPStabilizer__checkNode(CasADi::QPStabilizer* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__QPStabilizer__checkNode(CasADi::QPStabilizer* obj);
int CasADi__QPStabilizer__checkNode(CasADi::QPStabilizer* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::QPStabilizer"
// cppName: "CasADi::QPStabilizer::creator"
// cWrapperName: "CasADi__QPStabilizer__creator"
// protoArgs: "(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass StabilizedQPSolver
// cWrapperRetType: "CasADi::StabilizedQPSolver*"
// proto: "CasADi::StabilizedQPSolver* CasADi__QPStabilizer__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::QPStabilizer::creator(x0_)"
extern "C"
    CasADi::StabilizedQPSolver* CasADi__QPStabilizer__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::StabilizedQPSolver* CasADi__QPStabilizer__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::StabilizedQPSolver*, CasADi::StabilizedQPSolver >::wrapReturn( CasADi::QPStabilizer::creator(x0_) );
}


// ================== Normal method: "getSolver" ===============
// class: "CasADi::QPStabilizer"
// cppName: "CasADi::QPStabilizer::getSolver"
// cWrapperName: "CasADi__QPStabilizer__getSolver"
// protoArgs: "(CasADi::QPStabilizer* obj)"
// args: "()"
// rettype: CasadiClass QPSolver
// cWrapperRetType: "CasADi::QPSolver*"
// proto: "CasADi::QPSolver* CasADi__QPStabilizer__getSolver(CasADi::QPStabilizer* obj)"
// call: "obj->getSolver()"
extern "C"
    CasADi::QPSolver* CasADi__QPStabilizer__getSolver(CasADi::QPStabilizer* obj);
CasADi::QPSolver* CasADi__QPStabilizer__getSolver(CasADi::QPStabilizer* obj){

    return WrapReturn< CasADi::QPSolver*, CasADi::QPSolver >::wrapReturn( obj->getSolver() );
}


// ================== Constructor method: "QPStabilizer" ===============
// class: "CasADi::QPStabilizer"
// cppName: "CasADi::QPStabilizer"
// cWrapperName: "CasADi__QPStabilizer__QPStabilizer"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass QPStabilizer
// cWrapperRetType: "CasADi::QPStabilizer*"
// proto: "CasADi::QPStabilizer* CasADi__QPStabilizer__QPStabilizer()"
// call: "CasADi::QPStabilizer()"
extern "C"
    CasADi::QPStabilizer* CasADi__QPStabilizer__QPStabilizer();
CasADi::QPStabilizer* CasADi__QPStabilizer__QPStabilizer(){

    return WrapReturn< CasADi::QPStabilizer*, CasADi::QPStabilizer >::wrapReturn( CasADi::QPStabilizer() );
}


// ================== Constructor method: "QPStabilizer'" ===============
// class: "CasADi::QPStabilizer"
// cppName: "CasADi::QPStabilizer"
// cWrapperName: "CasADi__QPStabilizer__QPStabilizer_TIC"
// protoArgs: "(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QPStabilizer
// cWrapperRetType: "CasADi::QPStabilizer*"
// proto: "CasADi::QPStabilizer* CasADi__QPStabilizer__QPStabilizer_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::QPStabilizer(x0_)"
extern "C"
    CasADi::QPStabilizer* CasADi__QPStabilizer__QPStabilizer_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::QPStabilizer* CasADi__QPStabilizer__QPStabilizer_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::QPStabilizer*, CasADi::QPStabilizer >::wrapReturn( CasADi::QPStabilizer(x0_) );
}


// ================== delete CasadiClass GenIMatrix===============
// classType: CasadiClass GenIMatrix
extern "C"
    void delete_CasADi__GenericMatrix_CasADi__Matrix_int__(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
void delete_CasADi__GenericMatrix_CasADi__Matrix_int__(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){
    delete obj;
}

// ================== Normal method: "size" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::size"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____size"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____size(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____size(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____size(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size() );
}


// ================== Normal method: "sizeL" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sizeL"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sizeL"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____sizeL(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->sizeL()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____sizeL(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____sizeL(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeL() );
}


// ================== Normal method: "sizeU" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sizeU"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sizeU"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____sizeU(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->sizeU()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____sizeU(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____sizeU(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeU() );
}


// ================== Normal method: "sizeD" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sizeD"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sizeD"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____sizeD(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->sizeD()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____sizeD(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____sizeD(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeD() );
}


// ================== Normal method: "numel" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::numel"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____numel"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____numel(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____numel(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____numel(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->numel() );
}


// ================== Normal method: "size1" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::size1"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____size1"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____size1(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____size1(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____size1(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size1() );
}


// ================== Normal method: "size2" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::size2"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____size2"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____size2(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____size2(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____size2(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size2() );
}


// ================== Normal method: "size'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::size'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::SparsityType x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::SparsityType x0)"
// call: "obj->size(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::SparsityType x0);
int CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::SparsityType x0){
    CasADi::SparsityType x0_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->size(x0_) );
}


// ================== Normal method: "dimString" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::dimString"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____dimString"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericMatrix_CasADi__Matrix_int____dimString(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->dimString()"
extern "C"
    std::string* CasADi__GenericMatrix_CasADi__Matrix_int____dimString(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
std::string* CasADi__GenericMatrix_CasADi__Matrix_int____dimString(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->dimString() );
}


// ================== Normal method: "isEmpty" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isEmpty"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0)"
// call: "obj->isEmpty(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0);
int CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty(x0_) );
}


// ================== Normal method: "isEmpty'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isEmpty'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isEmpty()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty() );
}


// ================== Normal method: "isDense" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isDense"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isDense"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isDense(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isDense()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isDense(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isDense(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDense() );
}


// ================== Normal method: "isScalar" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isScalar"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isScalar"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isScalar(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0)"
// call: "obj->isScalar(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isScalar(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0);
int CasADi__GenericMatrix_CasADi__Matrix_int____isScalar(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar(x0_) );
}


// ================== Normal method: "isScalar'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isScalar'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isScalar()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar() );
}


// ================== Normal method: "isSquare" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isSquare"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isSquare"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isSquare(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isSquare()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isSquare(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isSquare(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSquare() );
}


// ================== Normal method: "isVector" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isVector"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isVector"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isVector(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isVector()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isVector(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isVector(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isVector() );
}


// ================== Normal method: "isTriu" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isTriu"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isTriu"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isTriu(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isTriu()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isTriu(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isTriu(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTriu() );
}


// ================== Normal method: "isTril" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::isTril"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____isTril"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_int____isTril(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->isTril()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_int____isTril(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_int____isTril(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTril() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparsityRef"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj);
CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Static method: "sym" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym"
// protoArgs: "(std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym(std::string* x0, int x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym(std::string* x0, int x1, int x2);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym(std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC"
// protoArgs: "(std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC(std::string* x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC(std::string* x0, int x1);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC(std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_) );
}


// ================== Static method: "sym''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC(std::string* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC(std::string* x0);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_) );
}


// ================== Static method: "sym'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_) );
}


// ================== Static method: "sym''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass IMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2);
std::vector< CasADi::Matrix< int >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym'''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (CasadiClass IMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);
std::vector< CasADi::Matrix< int >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (CasadiClass IMatrix))
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< int >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< int >* >* >*, std::vector< std::vector< CasADi::Matrix< int > > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym'''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym'''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (CasadiClass IMatrix))
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< int >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< int >* >* >*, std::vector< std::vector< CasADi::Matrix< int > > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sym(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "sparse" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sparse"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse(int x0, int x1);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC(int x0);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse(x0_) );
}


// ================== Static method: "sparse''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse()"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC();
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::sparse() );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____zeros"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros(int x0, int x1);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros(x0_, x1_) );
}


// ================== Static method: "zeros'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC(int x0);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros(x0_) );
}


// ================== Static method: "zeros''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros()"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC();
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros() );
}


// ================== Static method: "zeros'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____ones"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones(int x0, int x1);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::ones(x0_, x1_) );
}


// ================== Static method: "ones'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC(int x0);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::ones(x0_) );
}


// ================== Static method: "ones''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones()"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC();
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::ones() );
}


// ================== Static method: "ones'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< int > >::ones(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< int > >::ones(x0_) );
}


// ================== Normal method: "mul_smart" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< int > >::mul_smart"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->mul_smart(x0_, x1_) );
}


// ================== delete CasadiClass Callback===============
// classType: CasadiClass Callback
extern "C"
    void delete_CasADi__Callback(CasADi::Callback* obj);
void delete_CasADi__Callback(CasADi::Callback* obj){
    delete obj;
}

// ================== Constructor method: "Callback" ===============
// class: "CasADi::Callback"
// cppName: "CasADi::Callback"
// cWrapperName: "CasADi__Callback__Callback"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Callback
// cWrapperRetType: "CasADi::Callback*"
// proto: "CasADi::Callback* CasADi__Callback__Callback()"
// call: "CasADi::Callback()"
extern "C"
    CasADi::Callback* CasADi__Callback__Callback();
CasADi::Callback* CasADi__Callback__Callback(){

    return WrapReturn< CasADi::Callback*, CasADi::Callback >::wrapReturn( CasADi::Callback() );
}


// ================== delete CasadiClass SOCPQCQPSolver===============
// classType: CasadiClass SOCPQCQPSolver
extern "C"
    void delete_CasADi__SOCPQCQPSolver(CasADi::SOCPQCQPSolver* obj);
void delete_CasADi__SOCPQCQPSolver(CasADi::SOCPQCQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SOCPQCQPSolver"
// cppName: "CasADi::SOCPQCQPSolver::checkNode"
// cWrapperName: "CasADi__SOCPQCQPSolver__checkNode"
// protoArgs: "(CasADi::SOCPQCQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SOCPQCQPSolver__checkNode(CasADi::SOCPQCQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SOCPQCQPSolver__checkNode(CasADi::SOCPQCQPSolver* obj);
int CasADi__SOCPQCQPSolver__checkNode(CasADi::SOCPQCQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SOCPQCQPSolver"
// cppName: "CasADi::SOCPQCQPSolver::creator"
// cWrapperName: "CasADi__SOCPQCQPSolver__creator"
// protoArgs: "(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QCQPSolver
// cWrapperRetType: "CasADi::QCQPSolver*"
// proto: "CasADi::QCQPSolver* CasADi__SOCPQCQPSolver__creator(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::SOCPQCQPSolver::creator(x0_)"
extern "C"
    CasADi::QCQPSolver* CasADi__SOCPQCQPSolver__creator(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::QCQPSolver* CasADi__SOCPQCQPSolver__creator(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::QCQPSolver*, CasADi::QCQPSolver >::wrapReturn( CasADi::SOCPQCQPSolver::creator(x0_) );
}


// ================== Normal method: "getSolver" ===============
// class: "CasADi::SOCPQCQPSolver"
// cppName: "CasADi::SOCPQCQPSolver::getSolver"
// cWrapperName: "CasADi__SOCPQCQPSolver__getSolver"
// protoArgs: "(CasADi::SOCPQCQPSolver* obj)"
// args: "()"
// rettype: CasadiClass SOCPSolver
// cWrapperRetType: "CasADi::SOCPSolver*"
// proto: "CasADi::SOCPSolver* CasADi__SOCPQCQPSolver__getSolver(CasADi::SOCPQCQPSolver* obj)"
// call: "obj->getSolver()"
extern "C"
    CasADi::SOCPSolver* CasADi__SOCPQCQPSolver__getSolver(CasADi::SOCPQCQPSolver* obj);
CasADi::SOCPSolver* CasADi__SOCPQCQPSolver__getSolver(CasADi::SOCPQCQPSolver* obj){

    return WrapReturn< CasADi::SOCPSolver*, CasADi::SOCPSolver >::wrapReturn( obj->getSolver() );
}


// ================== Constructor method: "SOCPQCQPSolver" ===============
// class: "CasADi::SOCPQCQPSolver"
// cppName: "CasADi::SOCPQCQPSolver"
// cWrapperName: "CasADi__SOCPQCQPSolver__SOCPQCQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SOCPQCQPSolver
// cWrapperRetType: "CasADi::SOCPQCQPSolver*"
// proto: "CasADi::SOCPQCQPSolver* CasADi__SOCPQCQPSolver__SOCPQCQPSolver()"
// call: "CasADi::SOCPQCQPSolver()"
extern "C"
    CasADi::SOCPQCQPSolver* CasADi__SOCPQCQPSolver__SOCPQCQPSolver();
CasADi::SOCPQCQPSolver* CasADi__SOCPQCQPSolver__SOCPQCQPSolver(){

    return WrapReturn< CasADi::SOCPQCQPSolver*, CasADi::SOCPQCQPSolver >::wrapReturn( CasADi::SOCPQCQPSolver() );
}


// ================== Constructor method: "SOCPQCQPSolver'" ===============
// class: "CasADi::SOCPQCQPSolver"
// cppName: "CasADi::SOCPQCQPSolver"
// cWrapperName: "CasADi__SOCPQCQPSolver__SOCPQCQPSolver_TIC"
// protoArgs: "(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SOCPQCQPSolver
// cWrapperRetType: "CasADi::SOCPQCQPSolver*"
// proto: "CasADi::SOCPQCQPSolver* CasADi__SOCPQCQPSolver__SOCPQCQPSolver_TIC(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::SOCPQCQPSolver(x0_)"
extern "C"
    CasADi::SOCPQCQPSolver* CasADi__SOCPQCQPSolver__SOCPQCQPSolver_TIC(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::SOCPQCQPSolver* CasADi__SOCPQCQPSolver__SOCPQCQPSolver_TIC(CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QCQPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::SOCPQCQPSolver*, CasADi::SOCPQCQPSolver >::wrapReturn( CasADi::SOCPQCQPSolver(x0_) );
}


// ================== delete CasadiClass QCQPQPSolver===============
// classType: CasadiClass QCQPQPSolver
extern "C"
    void delete_CasADi__QCQPQPSolver(CasADi::QCQPQPSolver* obj);
void delete_CasADi__QCQPQPSolver(CasADi::QCQPQPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::QCQPQPSolver"
// cppName: "CasADi::QCQPQPSolver::checkNode"
// cWrapperName: "CasADi__QCQPQPSolver__checkNode"
// protoArgs: "(CasADi::QCQPQPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__QCQPQPSolver__checkNode(CasADi::QCQPQPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__QCQPQPSolver__checkNode(CasADi::QCQPQPSolver* obj);
int CasADi__QCQPQPSolver__checkNode(CasADi::QCQPQPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::QCQPQPSolver"
// cppName: "CasADi::QCQPQPSolver::creator"
// cWrapperName: "CasADi__QCQPQPSolver__creator"
// protoArgs: "(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QPSolver
// cWrapperRetType: "CasADi::QPSolver*"
// proto: "CasADi::QPSolver* CasADi__QCQPQPSolver__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::QCQPQPSolver::creator(x0_)"
extern "C"
    CasADi::QPSolver* CasADi__QCQPQPSolver__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::QPSolver* CasADi__QCQPQPSolver__creator(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::QPSolver*, CasADi::QPSolver >::wrapReturn( CasADi::QCQPQPSolver::creator(x0_) );
}


// ================== Normal method: "getSolver" ===============
// class: "CasADi::QCQPQPSolver"
// cppName: "CasADi::QCQPQPSolver::getSolver"
// cWrapperName: "CasADi__QCQPQPSolver__getSolver"
// protoArgs: "(CasADi::QCQPQPSolver* obj)"
// args: "()"
// rettype: CasadiClass QCQPSolver
// cWrapperRetType: "CasADi::QCQPSolver*"
// proto: "CasADi::QCQPSolver* CasADi__QCQPQPSolver__getSolver(CasADi::QCQPQPSolver* obj)"
// call: "obj->getSolver()"
extern "C"
    CasADi::QCQPSolver* CasADi__QCQPQPSolver__getSolver(CasADi::QCQPQPSolver* obj);
CasADi::QCQPSolver* CasADi__QCQPQPSolver__getSolver(CasADi::QCQPQPSolver* obj){

    return WrapReturn< CasADi::QCQPSolver*, CasADi::QCQPSolver >::wrapReturn( obj->getSolver() );
}


// ================== Constructor method: "QCQPQPSolver" ===============
// class: "CasADi::QCQPQPSolver"
// cppName: "CasADi::QCQPQPSolver"
// cWrapperName: "CasADi__QCQPQPSolver__QCQPQPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass QCQPQPSolver
// cWrapperRetType: "CasADi::QCQPQPSolver*"
// proto: "CasADi::QCQPQPSolver* CasADi__QCQPQPSolver__QCQPQPSolver()"
// call: "CasADi::QCQPQPSolver()"
extern "C"
    CasADi::QCQPQPSolver* CasADi__QCQPQPSolver__QCQPQPSolver();
CasADi::QCQPQPSolver* CasADi__QCQPQPSolver__QCQPQPSolver(){

    return WrapReturn< CasADi::QCQPQPSolver*, CasADi::QCQPQPSolver >::wrapReturn( CasADi::QCQPQPSolver() );
}


// ================== Constructor method: "QCQPQPSolver'" ===============
// class: "CasADi::QCQPQPSolver"
// cppName: "CasADi::QCQPQPSolver"
// cWrapperName: "CasADi__QCQPQPSolver__QCQPQPSolver_TIC"
// protoArgs: "(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QCQPQPSolver
// cWrapperRetType: "CasADi::QCQPQPSolver*"
// proto: "CasADi::QCQPQPSolver* CasADi__QCQPQPSolver__QCQPQPSolver_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0)"
// call: "CasADi::QCQPQPSolver(x0_)"
extern "C"
    CasADi::QCQPQPSolver* CasADi__QCQPQPSolver__QCQPQPSolver_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0);
CasADi::QCQPQPSolver* CasADi__QCQPQPSolver__QCQPQPSolver_TIC(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* x0){
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const & x0_ = Marshaling<CasADi::QPStructIOSchemeVector< CasADi::Sparsity > const &,CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*>::marshal(x0);

    return WrapReturn< CasADi::QCQPQPSolver*, CasADi::QCQPQPSolver >::wrapReturn( CasADi::QCQPQPSolver(x0_) );
}


// ================== delete CasadiClass ExpSX===============
// classType: CasadiClass ExpSX
extern "C"
    void delete_CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj);
void delete_CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj){
    delete obj;
}

// ================== Normal method: "__mldivide__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__mldivide__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______mldivide__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______mldivide__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__mldivide__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______mldivide__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______mldivide__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__mldivide__(x0_) );
}


// ================== Normal method: "__gt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__gt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______gt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______gt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__gt__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______gt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______gt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__gt__(x0_) );
}


// ================== Normal method: "__ge__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__ge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______ge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______ge__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__ge__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______ge__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______ge__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__ge__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__truediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______truediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______truediv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______truediv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______truediv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__radd__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__radd__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______radd__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______radd__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__radd__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______radd__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______radd__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__radd__(x0_) );
}


// ================== Normal method: "__rsub__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rsub__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rsub__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rsub__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rsub__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rsub__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rsub__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rsub__(x0_) );
}


// ================== Normal method: "__rmul__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rmul__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rmul__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rmul__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rmul__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rmul__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rmul__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rmul__(x0_) );
}


// ================== Normal method: "__rdiv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rdiv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rdiv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rdiv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rdiv__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rdiv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rdiv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rdiv__(x0_) );
}


// ================== Normal method: "__rlt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rlt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rlt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rlt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rlt__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rlt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rlt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rlt__(x0_) );
}


// ================== Normal method: "__rle__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rle__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rle__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rle__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rle__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rle__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rle__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rle__(x0_) );
}


// ================== Normal method: "__rgt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rgt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rgt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rgt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rgt__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rgt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rgt__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rgt__(x0_) );
}


// ================== Normal method: "__rge__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rge__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rge__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rge__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rge__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rge__(x0_) );
}


// ================== Normal method: "__req__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__req__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______req__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______req__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__req__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______req__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______req__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__req__(x0_) );
}


// ================== Normal method: "__rne__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rne__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rne__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rne__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rne__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rne__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rne__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rne__(x0_) );
}


// ================== Normal method: "__rtruediv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >::__rtruediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rtruediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__rtruediv__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__GenericExpression_CasADi__Matrix_CasADi__SXElement______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< CasADi::SXElement > >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__rtruediv__(x0_) );
}


// ================== delete CasadiClass Integrator===============
// classType: CasadiClass Integrator
extern "C"
    void delete_CasADi__Integrator(CasADi::Integrator* obj);
void delete_CasADi__Integrator(CasADi::Integrator* obj){
    delete obj;
}

// ================== Normal method: "clone" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::clone"
// cWrapperName: "CasADi__Integrator__clone"
// protoArgs: "(CasADi::Integrator* obj)"
// args: "()"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__Integrator__clone(CasADi::Integrator* obj)"
// call: "obj->clone()"
extern "C"
    CasADi::Integrator* CasADi__Integrator__clone(CasADi::Integrator* obj);
CasADi::Integrator* CasADi__Integrator__clone(CasADi::Integrator* obj){

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( obj->clone() );
}


// ================== Normal method: "printStats'" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::printStats'"
// cWrapperName: "CasADi__Integrator__printStats_TIC"
// protoArgs: "(CasADi::Integrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Integrator__printStats_TIC(CasADi::Integrator* obj)"
// call: "obj->printStats()"
extern "C"
    void CasADi__Integrator__printStats_TIC(CasADi::Integrator* obj);
void CasADi__Integrator__printStats_TIC(CasADi::Integrator* obj){

    obj->printStats();
}


// ================== Normal method: "reset" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::reset"
// cWrapperName: "CasADi__Integrator__reset"
// protoArgs: "(CasADi::Integrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Integrator__reset(CasADi::Integrator* obj)"
// call: "obj->reset()"
extern "C"
    void CasADi__Integrator__reset(CasADi::Integrator* obj);
void CasADi__Integrator__reset(CasADi::Integrator* obj){

    obj->reset();
}


// ================== Normal method: "integrate" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::integrate"
// cWrapperName: "CasADi__Integrator__integrate"
// protoArgs: "(CasADi::Integrator* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Integrator__integrate(CasADi::Integrator* obj, double x0)"
// call: "obj->integrate(x0_)"
extern "C"
    void CasADi__Integrator__integrate(CasADi::Integrator* obj, double x0);
void CasADi__Integrator__integrate(CasADi::Integrator* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->integrate(x0_);
}


// ================== Normal method: "resetB" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::resetB"
// cWrapperName: "CasADi__Integrator__resetB"
// protoArgs: "(CasADi::Integrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Integrator__resetB(CasADi::Integrator* obj)"
// call: "obj->resetB()"
extern "C"
    void CasADi__Integrator__resetB(CasADi::Integrator* obj);
void CasADi__Integrator__resetB(CasADi::Integrator* obj){

    obj->resetB();
}


// ================== Normal method: "integrateB" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::integrateB"
// cWrapperName: "CasADi__Integrator__integrateB"
// protoArgs: "(CasADi::Integrator* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Integrator__integrateB(CasADi::Integrator* obj, double x0)"
// call: "obj->integrateB(x0_)"
extern "C"
    void CasADi__Integrator__integrateB(CasADi::Integrator* obj, double x0);
void CasADi__Integrator__integrateB(CasADi::Integrator* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->integrateB(x0_);
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::checkNode"
// cWrapperName: "CasADi__Integrator__checkNode"
// protoArgs: "(CasADi::Integrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Integrator__checkNode(CasADi::Integrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__Integrator__checkNode(CasADi::Integrator* obj);
int CasADi__Integrator__checkNode(CasADi::Integrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getDAE" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator::getDAE"
// cWrapperName: "CasADi__Integrator__getDAE"
// protoArgs: "(CasADi::Integrator* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Integrator__getDAE(CasADi::Integrator* obj)"
// call: "obj->getDAE()"
extern "C"
    CasADi::Function* CasADi__Integrator__getDAE(CasADi::Integrator* obj);
CasADi::Function* CasADi__Integrator__getDAE(CasADi::Integrator* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getDAE() );
}


// ================== Constructor method: "Integrator" ===============
// class: "CasADi::Integrator"
// cppName: "CasADi::Integrator"
// cWrapperName: "CasADi__Integrator__Integrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__Integrator__Integrator()"
// call: "CasADi::Integrator()"
extern "C"
    CasADi::Integrator* CasADi__Integrator__Integrator();
CasADi::Integrator* CasADi__Integrator__Integrator(){

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( CasADi::Integrator() );
}


// ================== delete CasadiClass WeakRef===============
// classType: CasadiClass WeakRef
extern "C"
    void delete_CasADi__WeakRef(CasADi::WeakRef* obj);
void delete_CasADi__WeakRef(CasADi::WeakRef* obj){
    delete obj;
}

// ================== Normal method: "shared" ===============
// class: "CasADi::WeakRef"
// cppName: "CasADi::WeakRef::shared"
// cWrapperName: "CasADi__WeakRef__shared"
// protoArgs: "(CasADi::WeakRef* obj)"
// args: "()"
// rettype: CasadiClass SharedObject
// cWrapperRetType: "CasADi::SharedObject*"
// proto: "CasADi::SharedObject* CasADi__WeakRef__shared(CasADi::WeakRef* obj)"
// call: "obj->shared()"
extern "C"
    CasADi::SharedObject* CasADi__WeakRef__shared(CasADi::WeakRef* obj);
CasADi::SharedObject* CasADi__WeakRef__shared(CasADi::WeakRef* obj){

    return WrapReturn< CasADi::SharedObject*, CasADi::SharedObject >::wrapReturn( obj->shared() );
}


// ================== Normal method: "alive" ===============
// class: "CasADi::WeakRef"
// cppName: "CasADi::WeakRef::alive"
// cWrapperName: "CasADi__WeakRef__alive"
// protoArgs: "(CasADi::WeakRef* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__WeakRef__alive(CasADi::WeakRef* obj)"
// call: "obj->alive()"
extern "C"
    int CasADi__WeakRef__alive(CasADi::WeakRef* obj);
int CasADi__WeakRef__alive(CasADi::WeakRef* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->alive() );
}


// ================== Constructor method: "WeakRef" ===============
// class: "CasADi::WeakRef"
// cppName: "CasADi::WeakRef"
// cWrapperName: "CasADi__WeakRef__WeakRef"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass WeakRef
// cWrapperRetType: "CasADi::WeakRef*"
// proto: "CasADi::WeakRef* CasADi__WeakRef__WeakRef(int x0)"
// call: "CasADi::WeakRef(x0_)"
extern "C"
    CasADi::WeakRef* CasADi__WeakRef__WeakRef(int x0);
CasADi::WeakRef* CasADi__WeakRef__WeakRef(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::WeakRef*, CasADi::WeakRef >::wrapReturn( CasADi::WeakRef(x0_) );
}


// ================== Constructor method: "WeakRef'" ===============
// class: "CasADi::WeakRef"
// cppName: "CasADi::WeakRef"
// cWrapperName: "CasADi__WeakRef__WeakRef_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass WeakRef
// cWrapperRetType: "CasADi::WeakRef*"
// proto: "CasADi::WeakRef* CasADi__WeakRef__WeakRef_TIC()"
// call: "CasADi::WeakRef()"
extern "C"
    CasADi::WeakRef* CasADi__WeakRef__WeakRef_TIC();
CasADi::WeakRef* CasADi__WeakRef__WeakRef_TIC(){

    return WrapReturn< CasADi::WeakRef*, CasADi::WeakRef >::wrapReturn( CasADi::WeakRef() );
}


// ================== Constructor method: "WeakRef''" ===============
// class: "CasADi::WeakRef"
// cppName: "CasADi::WeakRef"
// cWrapperName: "CasADi__WeakRef__WeakRef_TIC_TIC"
// protoArgs: "(CasADi::SharedObject* x0)"
// args: "(x0_)"
// rettype: CasadiClass WeakRef
// cWrapperRetType: "CasADi::WeakRef*"
// proto: "CasADi::WeakRef* CasADi__WeakRef__WeakRef_TIC_TIC(CasADi::SharedObject* x0)"
// call: "CasADi::WeakRef(x0_)"
extern "C"
    CasADi::WeakRef* CasADi__WeakRef__WeakRef_TIC_TIC(CasADi::SharedObject* x0);
CasADi::WeakRef* CasADi__WeakRef__WeakRef_TIC_TIC(CasADi::SharedObject* x0){
    CasADi::SharedObject x0_ = Marshaling<CasADi::SharedObject,CasADi::SharedObject*>::marshal(x0);

    return WrapReturn< CasADi::WeakRef*, CasADi::WeakRef >::wrapReturn( CasADi::WeakRef(x0_) );
}


// ================== delete CasadiClass Simulator===============
// classType: CasadiClass Simulator
extern "C"
    void delete_CasADi__Simulator(CasADi::Simulator* obj);
void delete_CasADi__Simulator(CasADi::Simulator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::Simulator"
// cppName: "CasADi::Simulator::checkNode"
// cWrapperName: "CasADi__Simulator__checkNode"
// protoArgs: "(CasADi::Simulator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Simulator__checkNode(CasADi::Simulator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__Simulator__checkNode(CasADi::Simulator* obj);
int CasADi__Simulator__checkNode(CasADi::Simulator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "Simulator" ===============
// class: "CasADi::Simulator"
// cppName: "CasADi::Simulator"
// cWrapperName: "CasADi__Simulator__Simulator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Simulator
// cWrapperRetType: "CasADi::Simulator*"
// proto: "CasADi::Simulator* CasADi__Simulator__Simulator()"
// call: "CasADi::Simulator()"
extern "C"
    CasADi::Simulator* CasADi__Simulator__Simulator();
CasADi::Simulator* CasADi__Simulator__Simulator(){

    return WrapReturn< CasADi::Simulator*, CasADi::Simulator >::wrapReturn( CasADi::Simulator() );
}


// ================== Constructor method: "Simulator'" ===============
// class: "CasADi::Simulator"
// cppName: "CasADi::Simulator"
// cWrapperName: "CasADi__Simulator__Simulator_TIC"
// protoArgs: "(CasADi::Integrator* x0, CasADi::Function* x1, std::vector< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Simulator
// cWrapperRetType: "CasADi::Simulator*"
// proto: "CasADi::Simulator* CasADi__Simulator__Simulator_TIC(CasADi::Integrator* x0, CasADi::Function* x1, std::vector< double >* x2)"
// call: "CasADi::Simulator(x0_, x1_, x2_)"
extern "C"
    CasADi::Simulator* CasADi__Simulator__Simulator_TIC(CasADi::Integrator* x0, CasADi::Function* x1, std::vector< double >* x2);
CasADi::Simulator* CasADi__Simulator__Simulator_TIC(CasADi::Integrator* x0, CasADi::Function* x1, std::vector< double >* x2){
    CasADi::Integrator const & x0_ = Marshaling<CasADi::Integrator const &,CasADi::Integrator*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

    return WrapReturn< CasADi::Simulator*, CasADi::Simulator >::wrapReturn( CasADi::Simulator(x0_, x1_, x2_) );
}


// ================== Constructor method: "Simulator''" ===============
// class: "CasADi::Simulator"
// cppName: "CasADi::Simulator"
// cWrapperName: "CasADi__Simulator__Simulator_TIC_TIC"
// protoArgs: "(CasADi::Integrator* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Simulator
// cWrapperRetType: "CasADi::Simulator*"
// proto: "CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC(CasADi::Integrator* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::Simulator(x0_, x1_, x2_)"
extern "C"
    CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC(CasADi::Integrator* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2);
CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC(CasADi::Integrator* x0, CasADi::Function* x1, CasADi::Matrix< double >* x2){
    CasADi::Integrator const & x0_ = Marshaling<CasADi::Integrator const &,CasADi::Integrator*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::Simulator*, CasADi::Simulator >::wrapReturn( CasADi::Simulator(x0_, x1_, x2_) );
}


// ================== Constructor method: "Simulator'''" ===============
// class: "CasADi::Simulator"
// cppName: "CasADi::Simulator"
// cWrapperName: "CasADi__Simulator__Simulator_TIC_TIC_TIC"
// protoArgs: "(CasADi::Integrator* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Simulator
// cWrapperRetType: "CasADi::Simulator*"
// proto: "CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC_TIC(CasADi::Integrator* x0, std::vector< double >* x1)"
// call: "CasADi::Simulator(x0_, x1_)"
extern "C"
    CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC_TIC(CasADi::Integrator* x0, std::vector< double >* x1);
CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC_TIC(CasADi::Integrator* x0, std::vector< double >* x1){
    CasADi::Integrator const & x0_ = Marshaling<CasADi::Integrator const &,CasADi::Integrator*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    return WrapReturn< CasADi::Simulator*, CasADi::Simulator >::wrapReturn( CasADi::Simulator(x0_, x1_) );
}


// ================== Constructor method: "Simulator''''" ===============
// class: "CasADi::Simulator"
// cppName: "CasADi::Simulator"
// cWrapperName: "CasADi__Simulator__Simulator_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Integrator* x0, CasADi::Matrix< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Simulator
// cWrapperRetType: "CasADi::Simulator*"
// proto: "CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC_TIC_TIC(CasADi::Integrator* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::Simulator(x0_, x1_)"
extern "C"
    CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC_TIC_TIC(CasADi::Integrator* x0, CasADi::Matrix< double >* x1);
CasADi::Simulator* CasADi__Simulator__Simulator_TIC_TIC_TIC_TIC(CasADi::Integrator* x0, CasADi::Matrix< double >* x1){
    CasADi::Integrator const & x0_ = Marshaling<CasADi::Integrator const &,CasADi::Integrator*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Simulator*, CasADi::Simulator >::wrapReturn( CasADi::Simulator(x0_, x1_) );
}


// ================== delete CasadiClass Parallelizer===============
// classType: CasadiClass Parallelizer
extern "C"
    void delete_CasADi__Parallelizer(CasADi::Parallelizer* obj);
void delete_CasADi__Parallelizer(CasADi::Parallelizer* obj){
    delete obj;
}

// ================== Constructor method: "Parallelizer" ===============
// class: "CasADi::Parallelizer"
// cppName: "CasADi::Parallelizer"
// cWrapperName: "CasADi__Parallelizer__Parallelizer"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Parallelizer
// cWrapperRetType: "CasADi::Parallelizer*"
// proto: "CasADi::Parallelizer* CasADi__Parallelizer__Parallelizer()"
// call: "CasADi::Parallelizer()"
extern "C"
    CasADi::Parallelizer* CasADi__Parallelizer__Parallelizer();
CasADi::Parallelizer* CasADi__Parallelizer__Parallelizer(){

    return WrapReturn< CasADi::Parallelizer*, CasADi::Parallelizer >::wrapReturn( CasADi::Parallelizer() );
}


// ================== Constructor method: "Parallelizer'" ===============
// class: "CasADi::Parallelizer"
// cppName: "CasADi::Parallelizer"
// cWrapperName: "CasADi__Parallelizer__Parallelizer_TIC"
// protoArgs: "(std::vector< CasADi::Function* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass Parallelizer
// cWrapperRetType: "CasADi::Parallelizer*"
// proto: "CasADi::Parallelizer* CasADi__Parallelizer__Parallelizer_TIC(std::vector< CasADi::Function* >* x0)"
// call: "CasADi::Parallelizer(x0_)"
extern "C"
    CasADi::Parallelizer* CasADi__Parallelizer__Parallelizer_TIC(std::vector< CasADi::Function* >* x0);
CasADi::Parallelizer* CasADi__Parallelizer__Parallelizer_TIC(std::vector< CasADi::Function* >* x0){
    std::vector< CasADi::Function > x0_ = Marshaling<std::vector< CasADi::Function >,std::vector< CasADi::Function* >*>::marshal(x0);

    return WrapReturn< CasADi::Parallelizer*, CasADi::Parallelizer >::wrapReturn( CasADi::Parallelizer(x0_) );
}


// ================== delete CasadiClass SimpleHomotopyNLPSolver===============
// classType: CasadiClass SimpleHomotopyNLPSolver
extern "C"
    void delete_CasADi__SimpleHomotopyNLPSolver(CasADi::SimpleHomotopyNLPSolver* obj);
void delete_CasADi__SimpleHomotopyNLPSolver(CasADi::SimpleHomotopyNLPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SimpleHomotopyNLPSolver"
// cppName: "CasADi::SimpleHomotopyNLPSolver::checkNode"
// cWrapperName: "CasADi__SimpleHomotopyNLPSolver__checkNode"
// protoArgs: "(CasADi::SimpleHomotopyNLPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SimpleHomotopyNLPSolver__checkNode(CasADi::SimpleHomotopyNLPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SimpleHomotopyNLPSolver__checkNode(CasADi::SimpleHomotopyNLPSolver* obj);
int CasADi__SimpleHomotopyNLPSolver__checkNode(CasADi::SimpleHomotopyNLPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SimpleHomotopyNLPSolver"
// cppName: "CasADi::SimpleHomotopyNLPSolver::creator"
// cWrapperName: "CasADi__SimpleHomotopyNLPSolver__creator"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass HomotopyNLPSolver
// cWrapperRetType: "CasADi::HomotopyNLPSolver*"
// proto: "CasADi::HomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__creator(CasADi::Function* x0)"
// call: "CasADi::SimpleHomotopyNLPSolver::creator(x0_)"
extern "C"
    CasADi::HomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__creator(CasADi::Function* x0);
CasADi::HomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__creator(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::HomotopyNLPSolver*, CasADi::HomotopyNLPSolver >::wrapReturn( CasADi::SimpleHomotopyNLPSolver::creator(x0_) );
}


// ================== Constructor method: "SimpleHomotopyNLPSolver" ===============
// class: "CasADi::SimpleHomotopyNLPSolver"
// cppName: "CasADi::SimpleHomotopyNLPSolver"
// cWrapperName: "CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SimpleHomotopyNLPSolver
// cWrapperRetType: "CasADi::SimpleHomotopyNLPSolver*"
// proto: "CasADi::SimpleHomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver()"
// call: "CasADi::SimpleHomotopyNLPSolver()"
extern "C"
    CasADi::SimpleHomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver();
CasADi::SimpleHomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver(){

    return WrapReturn< CasADi::SimpleHomotopyNLPSolver*, CasADi::SimpleHomotopyNLPSolver >::wrapReturn( CasADi::SimpleHomotopyNLPSolver() );
}


// ================== Constructor method: "SimpleHomotopyNLPSolver'" ===============
// class: "CasADi::SimpleHomotopyNLPSolver"
// cppName: "CasADi::SimpleHomotopyNLPSolver"
// cWrapperName: "CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass SimpleHomotopyNLPSolver
// cWrapperRetType: "CasADi::SimpleHomotopyNLPSolver*"
// proto: "CasADi::SimpleHomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver_TIC(CasADi::Function* x0)"
// call: "CasADi::SimpleHomotopyNLPSolver(x0_)"
extern "C"
    CasADi::SimpleHomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver_TIC(CasADi::Function* x0);
CasADi::SimpleHomotopyNLPSolver* CasADi__SimpleHomotopyNLPSolver__SimpleHomotopyNLPSolver_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::SimpleHomotopyNLPSolver*, CasADi::SimpleHomotopyNLPSolver >::wrapReturn( CasADi::SimpleHomotopyNLPSolver(x0_) );
}


// ================== delete CasadiClass SundialsIntegrator===============
// classType: CasadiClass SundialsIntegrator
extern "C"
    void delete_CasADi__SundialsIntegrator(CasADi::SundialsIntegrator* obj);
void delete_CasADi__SundialsIntegrator(CasADi::SundialsIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SundialsIntegrator"
// cppName: "CasADi::SundialsIntegrator::checkNode"
// cWrapperName: "CasADi__SundialsIntegrator__checkNode"
// protoArgs: "(CasADi::SundialsIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SundialsIntegrator__checkNode(CasADi::SundialsIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SundialsIntegrator__checkNode(CasADi::SundialsIntegrator* obj);
int CasADi__SundialsIntegrator__checkNode(CasADi::SundialsIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "setStopTime" ===============
// class: "CasADi::SundialsIntegrator"
// cppName: "CasADi::SundialsIntegrator::setStopTime"
// cWrapperName: "CasADi__SundialsIntegrator__setStopTime"
// protoArgs: "(CasADi::SundialsIntegrator* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SundialsIntegrator__setStopTime(CasADi::SundialsIntegrator* obj, double x0)"
// call: "obj->setStopTime(x0_)"
extern "C"
    void CasADi__SundialsIntegrator__setStopTime(CasADi::SundialsIntegrator* obj, double x0);
void CasADi__SundialsIntegrator__setStopTime(CasADi::SundialsIntegrator* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->setStopTime(x0_);
}


// ================== Constructor method: "SundialsIntegrator" ===============
// class: "CasADi::SundialsIntegrator"
// cppName: "CasADi::SundialsIntegrator"
// cWrapperName: "CasADi__SundialsIntegrator__SundialsIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SundialsIntegrator
// cWrapperRetType: "CasADi::SundialsIntegrator*"
// proto: "CasADi::SundialsIntegrator* CasADi__SundialsIntegrator__SundialsIntegrator()"
// call: "CasADi::SundialsIntegrator()"
extern "C"
    CasADi::SundialsIntegrator* CasADi__SundialsIntegrator__SundialsIntegrator();
CasADi::SundialsIntegrator* CasADi__SundialsIntegrator__SundialsIntegrator(){

    return WrapReturn< CasADi::SundialsIntegrator*, CasADi::SundialsIntegrator >::wrapReturn( CasADi::SundialsIntegrator() );
}


// ================== delete CasadiClass QPSolver===============
// classType: CasadiClass QPSolver
extern "C"
    void delete_CasADi__QPSolver(CasADi::QPSolver* obj);
void delete_CasADi__QPSolver(CasADi::QPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::QPSolver"
// cppName: "CasADi::QPSolver::checkNode"
// cWrapperName: "CasADi__QPSolver__checkNode"
// protoArgs: "(CasADi::QPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__QPSolver__checkNode(CasADi::QPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__QPSolver__checkNode(CasADi::QPSolver* obj);
int CasADi__QPSolver__checkNode(CasADi::QPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "setLPOptions" ===============
// class: "CasADi::QPSolver"
// cppName: "CasADi::QPSolver::setLPOptions"
// cWrapperName: "CasADi__QPSolver__setLPOptions"
// protoArgs: "(CasADi::QPSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__QPSolver__setLPOptions(CasADi::QPSolver* obj)"
// call: "obj->setLPOptions()"
extern "C"
    void CasADi__QPSolver__setLPOptions(CasADi::QPSolver* obj);
void CasADi__QPSolver__setLPOptions(CasADi::QPSolver* obj){

    obj->setLPOptions();
}


// ================== Normal method: "generateNativeCode" ===============
// class: "CasADi::QPSolver"
// cppName: "CasADi::QPSolver::generateNativeCode"
// cWrapperName: "CasADi__QPSolver__generateNativeCode"
// protoArgs: "(CasADi::QPSolver* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__QPSolver__generateNativeCode(CasADi::QPSolver* obj, std::string* x0)"
// call: "obj->generateNativeCode(x0_)"
extern "C"
    void CasADi__QPSolver__generateNativeCode(CasADi::QPSolver* obj, std::string* x0);
void CasADi__QPSolver__generateNativeCode(CasADi::QPSolver* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->generateNativeCode(x0_);
}


// ================== Constructor method: "QPSolver" ===============
// class: "CasADi::QPSolver"
// cppName: "CasADi::QPSolver"
// cWrapperName: "CasADi__QPSolver__QPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass QPSolver
// cWrapperRetType: "CasADi::QPSolver*"
// proto: "CasADi::QPSolver* CasADi__QPSolver__QPSolver()"
// call: "CasADi::QPSolver()"
extern "C"
    CasADi::QPSolver* CasADi__QPSolver__QPSolver();
CasADi::QPSolver* CasADi__QPSolver__QPSolver(){

    return WrapReturn< CasADi::QPSolver*, CasADi::QPSolver >::wrapReturn( CasADi::QPSolver() );
}


// ================== delete CasadiClass Nullspace===============
// classType: CasadiClass Nullspace
extern "C"
    void delete_CasADi__Nullspace(CasADi::Nullspace* obj);
void delete_CasADi__Nullspace(CasADi::Nullspace* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::Nullspace"
// cppName: "CasADi::Nullspace::checkNode"
// cWrapperName: "CasADi__Nullspace__checkNode"
// protoArgs: "(CasADi::Nullspace* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Nullspace__checkNode(CasADi::Nullspace* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__Nullspace__checkNode(CasADi::Nullspace* obj);
int CasADi__Nullspace__checkNode(CasADi::Nullspace* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "Nullspace" ===============
// class: "CasADi::Nullspace"
// cppName: "CasADi::Nullspace"
// cWrapperName: "CasADi__Nullspace__Nullspace"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Nullspace
// cWrapperRetType: "CasADi::Nullspace*"
// proto: "CasADi::Nullspace* CasADi__Nullspace__Nullspace()"
// call: "CasADi::Nullspace()"
extern "C"
    CasADi::Nullspace* CasADi__Nullspace__Nullspace();
CasADi::Nullspace* CasADi__Nullspace__Nullspace(){

    return WrapReturn< CasADi::Nullspace*, CasADi::Nullspace >::wrapReturn( CasADi::Nullspace() );
}


// ================== delete CasadiClass IdasIntegrator===============
// classType: CasadiClass IdasIntegrator
extern "C"
    void delete_CasADi__IdasIntegrator(CasADi::IdasIntegrator* obj);
void delete_CasADi__IdasIntegrator(CasADi::IdasIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::IdasIntegrator"
// cppName: "CasADi::IdasIntegrator::checkNode"
// cWrapperName: "CasADi__IdasIntegrator__checkNode"
// protoArgs: "(CasADi::IdasIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__IdasIntegrator__checkNode(CasADi::IdasIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__IdasIntegrator__checkNode(CasADi::IdasIntegrator* obj);
int CasADi__IdasIntegrator__checkNode(CasADi::IdasIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "correctInitialConditions" ===============
// class: "CasADi::IdasIntegrator"
// cppName: "CasADi::IdasIntegrator::correctInitialConditions"
// cWrapperName: "CasADi__IdasIntegrator__correctInitialConditions"
// protoArgs: "(CasADi::IdasIntegrator* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IdasIntegrator__correctInitialConditions(CasADi::IdasIntegrator* obj)"
// call: "obj->correctInitialConditions()"
extern "C"
    void CasADi__IdasIntegrator__correctInitialConditions(CasADi::IdasIntegrator* obj);
void CasADi__IdasIntegrator__correctInitialConditions(CasADi::IdasIntegrator* obj){

    obj->correctInitialConditions();
}


// ================== Static method: "creator" ===============
// class: "CasADi::IdasIntegrator"
// cppName: "CasADi::IdasIntegrator::creator"
// cWrapperName: "CasADi__IdasIntegrator__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__IdasIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::IdasIntegrator::creator(x0_, x1_)"
extern "C"
    CasADi::Integrator* CasADi__IdasIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1);
CasADi::Integrator* CasADi__IdasIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( CasADi::IdasIntegrator::creator(x0_, x1_) );
}


// ================== Constructor method: "IdasIntegrator" ===============
// class: "CasADi::IdasIntegrator"
// cppName: "CasADi::IdasIntegrator"
// cWrapperName: "CasADi__IdasIntegrator__IdasIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IdasIntegrator
// cWrapperRetType: "CasADi::IdasIntegrator*"
// proto: "CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator()"
// call: "CasADi::IdasIntegrator()"
extern "C"
    CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator();
CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator(){

    return WrapReturn< CasADi::IdasIntegrator*, CasADi::IdasIntegrator >::wrapReturn( CasADi::IdasIntegrator() );
}


// ================== Constructor method: "IdasIntegrator'" ===============
// class: "CasADi::IdasIntegrator"
// cppName: "CasADi::IdasIntegrator"
// cWrapperName: "CasADi__IdasIntegrator__IdasIntegrator_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IdasIntegrator
// cWrapperRetType: "CasADi::IdasIntegrator*"
// proto: "CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::IdasIntegrator(x0_, x1_)"
extern "C"
    CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::IdasIntegrator*, CasADi::IdasIntegrator >::wrapReturn( CasADi::IdasIntegrator(x0_, x1_) );
}


// ================== Constructor method: "IdasIntegrator''" ===============
// class: "CasADi::IdasIntegrator"
// cppName: "CasADi::IdasIntegrator"
// cWrapperName: "CasADi__IdasIntegrator__IdasIntegrator_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass IdasIntegrator
// cWrapperRetType: "CasADi::IdasIntegrator*"
// proto: "CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::IdasIntegrator(x0_)"
extern "C"
    CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator_TIC_TIC(CasADi::Function* x0);
CasADi::IdasIntegrator* CasADi__IdasIntegrator__IdasIntegrator_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::IdasIntegrator*, CasADi::IdasIntegrator >::wrapReturn( CasADi::IdasIntegrator(x0_) );
}


// ================== delete CasadiClass ExpSXElement===============
// classType: CasadiClass ExpSXElement
extern "C"
    void delete_CasADi__GenericExpression_CasADi__SXElement_(CasADi::GenericExpression< CasADi::SXElement >* obj);
void delete_CasADi__GenericExpression_CasADi__SXElement_(CasADi::GenericExpression< CasADi::SXElement >* obj){
    delete obj;
}

// ================== Normal method: "__mldivide__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__mldivide__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____mldivide__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____mldivide__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__mldivide__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____mldivide__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____mldivide__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__mldivide__(x0_) );
}


// ================== Normal method: "__gt__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__gt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____gt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____gt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__gt__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____gt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____gt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__gt__(x0_) );
}


// ================== Normal method: "__ge__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__ge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____ge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____ge__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__ge__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____ge__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____ge__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__ge__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__truediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____truediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____truediv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____truediv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____truediv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__radd__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__radd__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____radd__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____radd__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__radd__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____radd__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____radd__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__radd__(x0_) );
}


// ================== Normal method: "__rsub__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rsub__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rsub__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rsub__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rsub__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rsub__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rsub__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rsub__(x0_) );
}


// ================== Normal method: "__rmul__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rmul__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rmul__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rmul__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rmul__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rmul__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rmul__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rmul__(x0_) );
}


// ================== Normal method: "__rdiv__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rdiv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rdiv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rdiv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rdiv__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rdiv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rdiv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rdiv__(x0_) );
}


// ================== Normal method: "__rlt__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rlt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rlt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rlt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rlt__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rlt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rlt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rlt__(x0_) );
}


// ================== Normal method: "__rle__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rle__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rle__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rle__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rle__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rle__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rle__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rle__(x0_) );
}


// ================== Normal method: "__rgt__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rgt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rgt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rgt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rgt__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rgt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rgt__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rgt__(x0_) );
}


// ================== Normal method: "__rge__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rge__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rge__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rge__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rge__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rge__(x0_) );
}


// ================== Normal method: "__req__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__req__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____req__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____req__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__req__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____req__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____req__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__req__(x0_) );
}


// ================== Normal method: "__rne__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rne__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rne__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rne__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rne__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rne__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rne__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rne__(x0_) );
}


// ================== Normal method: "__rtruediv__" ===============
// class: "CasADi::GenericExpression< CasADi::SXElement >"
// cppName: "CasADi::GenericExpression< CasADi::SXElement >::__rtruediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__SXElement_____rtruediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rtruediv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->__rtruediv__(x0_)"
extern "C"
    CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rtruediv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0);
CasADi::SXElement* CasADi__GenericExpression_CasADi__SXElement_____rtruediv__(CasADi::GenericExpression< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->__rtruediv__(x0_) );
}


// ================== delete CasadiClass NewtonImplicitSolver===============
// classType: CasadiClass NewtonImplicitSolver
extern "C"
    void delete_CasADi__NewtonImplicitSolver(CasADi::NewtonImplicitSolver* obj);
void delete_CasADi__NewtonImplicitSolver(CasADi::NewtonImplicitSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::NewtonImplicitSolver"
// cppName: "CasADi::NewtonImplicitSolver::checkNode"
// cWrapperName: "CasADi__NewtonImplicitSolver__checkNode"
// protoArgs: "(CasADi::NewtonImplicitSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__NewtonImplicitSolver__checkNode(CasADi::NewtonImplicitSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__NewtonImplicitSolver__checkNode(CasADi::NewtonImplicitSolver* obj);
int CasADi__NewtonImplicitSolver__checkNode(CasADi::NewtonImplicitSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::NewtonImplicitSolver"
// cppName: "CasADi::NewtonImplicitSolver::creator"
// cWrapperName: "CasADi__NewtonImplicitSolver__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass ImplicitFunction
// cWrapperRetType: "CasADi::ImplicitFunction*"
// proto: "CasADi::ImplicitFunction* CasADi__NewtonImplicitSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// call: "CasADi::NewtonImplicitSolver::creator(x0_, x1_, x2_)"
extern "C"
    CasADi::ImplicitFunction* CasADi__NewtonImplicitSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2);
CasADi::ImplicitFunction* CasADi__NewtonImplicitSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::LinearSolver const & x2_ = Marshaling<CasADi::LinearSolver const &,CasADi::LinearSolver*>::marshal(x2);

    return WrapReturn< CasADi::ImplicitFunction*, CasADi::ImplicitFunction >::wrapReturn( CasADi::NewtonImplicitSolver::creator(x0_, x1_, x2_) );
}


// ================== Constructor method: "NewtonImplicitSolver" ===============
// class: "CasADi::NewtonImplicitSolver"
// cppName: "CasADi::NewtonImplicitSolver"
// cWrapperName: "CasADi__NewtonImplicitSolver__NewtonImplicitSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass NewtonImplicitSolver
// cWrapperRetType: "CasADi::NewtonImplicitSolver*"
// proto: "CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver()"
// call: "CasADi::NewtonImplicitSolver()"
extern "C"
    CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver();
CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver(){

    return WrapReturn< CasADi::NewtonImplicitSolver*, CasADi::NewtonImplicitSolver >::wrapReturn( CasADi::NewtonImplicitSolver() );
}


// ================== Constructor method: "NewtonImplicitSolver'" ===============
// class: "CasADi::NewtonImplicitSolver"
// cppName: "CasADi::NewtonImplicitSolver"
// cWrapperName: "CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass NewtonImplicitSolver
// cWrapperRetType: "CasADi::NewtonImplicitSolver*"
// proto: "CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// call: "CasADi::NewtonImplicitSolver(x0_, x1_, x2_)"
extern "C"
    CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2);
CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::LinearSolver const & x2_ = Marshaling<CasADi::LinearSolver const &,CasADi::LinearSolver*>::marshal(x2);

    return WrapReturn< CasADi::NewtonImplicitSolver*, CasADi::NewtonImplicitSolver >::wrapReturn( CasADi::NewtonImplicitSolver(x0_, x1_, x2_) );
}


// ================== Constructor method: "NewtonImplicitSolver''" ===============
// class: "CasADi::NewtonImplicitSolver"
// cppName: "CasADi::NewtonImplicitSolver"
// cWrapperName: "CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass NewtonImplicitSolver
// cWrapperRetType: "CasADi::NewtonImplicitSolver*"
// proto: "CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::NewtonImplicitSolver(x0_, x1_)"
extern "C"
    CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::NewtonImplicitSolver*, CasADi::NewtonImplicitSolver >::wrapReturn( CasADi::NewtonImplicitSolver(x0_, x1_) );
}


// ================== Constructor method: "NewtonImplicitSolver'''" ===============
// class: "CasADi::NewtonImplicitSolver"
// cppName: "CasADi::NewtonImplicitSolver"
// cWrapperName: "CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass NewtonImplicitSolver
// cWrapperRetType: "CasADi::NewtonImplicitSolver*"
// proto: "CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::NewtonImplicitSolver(x0_)"
extern "C"
    CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC_TIC(CasADi::Function* x0);
CasADi::NewtonImplicitSolver* CasADi__NewtonImplicitSolver__NewtonImplicitSolver_TIC_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::NewtonImplicitSolver*, CasADi::NewtonImplicitSolver >::wrapReturn( CasADi::NewtonImplicitSolver(x0_) );
}



// ================== delete CasadiClass KinsolSolver===============
// classType: CasadiClass KinsolSolver
extern "C"
    void delete_CasADi__KinsolSolver(CasADi::KinsolSolver* obj);
void delete_CasADi__KinsolSolver(CasADi::KinsolSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::KinsolSolver"
// cppName: "CasADi::KinsolSolver::checkNode"
// cWrapperName: "CasADi__KinsolSolver__checkNode"
// protoArgs: "(CasADi::KinsolSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__KinsolSolver__checkNode(CasADi::KinsolSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__KinsolSolver__checkNode(CasADi::KinsolSolver* obj);
int CasADi__KinsolSolver__checkNode(CasADi::KinsolSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::KinsolSolver"
// cppName: "CasADi::KinsolSolver::creator"
// cWrapperName: "CasADi__KinsolSolver__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass ImplicitFunction
// cWrapperRetType: "CasADi::ImplicitFunction*"
// proto: "CasADi::ImplicitFunction* CasADi__KinsolSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// call: "CasADi::KinsolSolver::creator(x0_, x1_, x2_)"
extern "C"
    CasADi::ImplicitFunction* CasADi__KinsolSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2);
CasADi::ImplicitFunction* CasADi__KinsolSolver__creator(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::LinearSolver const & x2_ = Marshaling<CasADi::LinearSolver const &,CasADi::LinearSolver*>::marshal(x2);

    return WrapReturn< CasADi::ImplicitFunction*, CasADi::ImplicitFunction >::wrapReturn( CasADi::KinsolSolver::creator(x0_, x1_, x2_) );
}


// ================== Constructor method: "KinsolSolver" ===============
// class: "CasADi::KinsolSolver"
// cppName: "CasADi::KinsolSolver"
// cWrapperName: "CasADi__KinsolSolver__KinsolSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass KinsolSolver
// cWrapperRetType: "CasADi::KinsolSolver*"
// proto: "CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver()"
// call: "CasADi::KinsolSolver()"
extern "C"
    CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver();
CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver(){

    return WrapReturn< CasADi::KinsolSolver*, CasADi::KinsolSolver >::wrapReturn( CasADi::KinsolSolver() );
}


// ================== Constructor method: "KinsolSolver'" ===============
// class: "CasADi::KinsolSolver"
// cppName: "CasADi::KinsolSolver"
// cWrapperName: "CasADi__KinsolSolver__KinsolSolver_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass KinsolSolver
// cWrapperRetType: "CasADi::KinsolSolver*"
// proto: "CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2)"
// call: "CasADi::KinsolSolver(x0_, x1_, x2_)"
extern "C"
    CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2);
CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::LinearSolver* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::LinearSolver const & x2_ = Marshaling<CasADi::LinearSolver const &,CasADi::LinearSolver*>::marshal(x2);

    return WrapReturn< CasADi::KinsolSolver*, CasADi::KinsolSolver >::wrapReturn( CasADi::KinsolSolver(x0_, x1_, x2_) );
}


// ================== Constructor method: "KinsolSolver''" ===============
// class: "CasADi::KinsolSolver"
// cppName: "CasADi::KinsolSolver"
// cWrapperName: "CasADi__KinsolSolver__KinsolSolver_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass KinsolSolver
// cWrapperRetType: "CasADi::KinsolSolver*"
// proto: "CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::KinsolSolver(x0_, x1_)"
extern "C"
    CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::KinsolSolver*, CasADi::KinsolSolver >::wrapReturn( CasADi::KinsolSolver(x0_, x1_) );
}


// ================== Constructor method: "KinsolSolver'''" ===============
// class: "CasADi::KinsolSolver"
// cppName: "CasADi::KinsolSolver"
// cWrapperName: "CasADi__KinsolSolver__KinsolSolver_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass KinsolSolver
// cWrapperRetType: "CasADi::KinsolSolver*"
// proto: "CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::KinsolSolver(x0_)"
extern "C"
    CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC_TIC_TIC(CasADi::Function* x0);
CasADi::KinsolSolver* CasADi__KinsolSolver__KinsolSolver_TIC_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::KinsolSolver*, CasADi::KinsolSolver >::wrapReturn( CasADi::KinsolSolver(x0_) );
}


// ================== delete CasadiClass QPStructure===============
// classType: CasadiClass QPStructure
extern "C"
    void delete_CasADi__QPStructIOSchemeVector_CasADi__Sparsity_(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* obj);
void delete_CasADi__QPStructIOSchemeVector_CasADi__Sparsity_(CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* obj){
    delete obj;
}

// ================== Constructor method: "QPStructure" ===============
// class: "CasADi::QPStructIOSchemeVector< CasADi::Sparsity >"
// cppName: "CasADi::QPStructIOSchemeVector< CasADi::Sparsity >"
// cWrapperName: "CasADi__QPStructIOSchemeVector_CasADi__Sparsity___QPStructure"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass QPStructure
// cWrapperRetType: "CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*"
// proto: "CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* CasADi__QPStructIOSchemeVector_CasADi__Sparsity___QPStructure(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::QPStructIOSchemeVector< CasADi::Sparsity >(x0_)"
extern "C"
    CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* CasADi__QPStructIOSchemeVector_CasADi__Sparsity___QPStructure(std::vector< CasADi::Sparsity* >* x0);
CasADi::QPStructIOSchemeVector< CasADi::Sparsity >* CasADi__QPStructIOSchemeVector_CasADi__Sparsity___QPStructure(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::QPStructIOSchemeVector< CasADi::Sparsity >*, CasADi::QPStructIOSchemeVector< CasADi::Sparsity > >::wrapReturn( CasADi::QPStructIOSchemeVector< CasADi::Sparsity >(x0_) );
}


// ================== delete CasadiClass CasadiMeta===============
// classType: CasadiClass CasadiMeta
extern "C"
    void delete_CasADi__CasadiMeta(CasADi::CasadiMeta* obj);
void delete_CasADi__CasadiMeta(CasADi::CasadiMeta* obj){
    delete obj;
}

// ================== Static method: "getVersion" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getVersion"
// cWrapperName: "CasADi__CasadiMeta__getVersion"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getVersion()"
// call: "CasADi::CasadiMeta::getVersion()"
extern "C"
    std::string* CasADi__CasadiMeta__getVersion();
std::string* CasADi__CasadiMeta__getVersion(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getVersion() );
}


// ================== Static method: "getGitRevision" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getGitRevision"
// cWrapperName: "CasADi__CasadiMeta__getGitRevision"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getGitRevision()"
// call: "CasADi::CasadiMeta::getGitRevision()"
extern "C"
    std::string* CasADi__CasadiMeta__getGitRevision();
std::string* CasADi__CasadiMeta__getGitRevision(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getGitRevision() );
}


// ================== Static method: "getGitDescribe" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getGitDescribe"
// cWrapperName: "CasADi__CasadiMeta__getGitDescribe"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getGitDescribe()"
// call: "CasADi::CasadiMeta::getGitDescribe()"
extern "C"
    std::string* CasADi__CasadiMeta__getGitDescribe();
std::string* CasADi__CasadiMeta__getGitDescribe(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getGitDescribe() );
}


// ================== Static method: "getFeatureList" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getFeatureList"
// cWrapperName: "CasADi__CasadiMeta__getFeatureList"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getFeatureList()"
// call: "CasADi::CasadiMeta::getFeatureList()"
extern "C"
    std::string* CasADi__CasadiMeta__getFeatureList();
std::string* CasADi__CasadiMeta__getFeatureList(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getFeatureList() );
}


// ================== Static method: "getBuildType" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getBuildType"
// cWrapperName: "CasADi__CasadiMeta__getBuildType"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getBuildType()"
// call: "CasADi::CasadiMeta::getBuildType()"
extern "C"
    std::string* CasADi__CasadiMeta__getBuildType();
std::string* CasADi__CasadiMeta__getBuildType(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getBuildType() );
}


// ================== Static method: "getCompilerId" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getCompilerId"
// cWrapperName: "CasADi__CasadiMeta__getCompilerId"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getCompilerId()"
// call: "CasADi::CasadiMeta::getCompilerId()"
extern "C"
    std::string* CasADi__CasadiMeta__getCompilerId();
std::string* CasADi__CasadiMeta__getCompilerId(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getCompilerId() );
}


// ================== Static method: "getCompiler" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getCompiler"
// cWrapperName: "CasADi__CasadiMeta__getCompiler"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getCompiler()"
// call: "CasADi::CasadiMeta::getCompiler()"
extern "C"
    std::string* CasADi__CasadiMeta__getCompiler();
std::string* CasADi__CasadiMeta__getCompiler(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getCompiler() );
}


// ================== Static method: "getCompilerFlags" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getCompilerFlags"
// cWrapperName: "CasADi__CasadiMeta__getCompilerFlags"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CasadiMeta__getCompilerFlags()"
// call: "CasADi::CasadiMeta::getCompilerFlags()"
extern "C"
    std::string* CasADi__CasadiMeta__getCompilerFlags();
std::string* CasADi__CasadiMeta__getCompilerFlags(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::CasadiMeta::getCompilerFlags() );
}


// ================== delete CasadiClass SymbolicQR===============
// classType: CasadiClass SymbolicQR
extern "C"
    void delete_CasADi__SymbolicQR(CasADi::SymbolicQR* obj);
void delete_CasADi__SymbolicQR(CasADi::SymbolicQR* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SymbolicQR"
// cppName: "CasADi::SymbolicQR::checkNode"
// cWrapperName: "CasADi__SymbolicQR__checkNode"
// protoArgs: "(CasADi::SymbolicQR* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SymbolicQR__checkNode(CasADi::SymbolicQR* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SymbolicQR__checkNode(CasADi::SymbolicQR* obj);
int CasADi__SymbolicQR__checkNode(CasADi::SymbolicQR* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::SymbolicQR"
// cppName: "CasADi::SymbolicQR::creator"
// cWrapperName: "CasADi__SymbolicQR__creator"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__SymbolicQR__creator(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::SymbolicQR::creator(x0_, x1_)"
extern "C"
    CasADi::LinearSolver* CasADi__SymbolicQR__creator(CasADi::Sparsity* x0, int x1);
CasADi::LinearSolver* CasADi__SymbolicQR__creator(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( CasADi::SymbolicQR::creator(x0_, x1_) );
}


// ================== Constructor method: "SymbolicQR" ===============
// class: "CasADi::SymbolicQR"
// cppName: "CasADi::SymbolicQR"
// cWrapperName: "CasADi__SymbolicQR__SymbolicQR"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SymbolicQR
// cWrapperRetType: "CasADi::SymbolicQR*"
// proto: "CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR()"
// call: "CasADi::SymbolicQR()"
extern "C"
    CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR();
CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR(){

    return WrapReturn< CasADi::SymbolicQR*, CasADi::SymbolicQR >::wrapReturn( CasADi::SymbolicQR() );
}


// ================== Constructor method: "SymbolicQR'" ===============
// class: "CasADi::SymbolicQR"
// cppName: "CasADi::SymbolicQR"
// cWrapperName: "CasADi__SymbolicQR__SymbolicQR_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SymbolicQR
// cWrapperRetType: "CasADi::SymbolicQR*"
// proto: "CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::SymbolicQR(x0_, x1_)"
extern "C"
    CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR_TIC(CasADi::Sparsity* x0, int x1);
CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::SymbolicQR*, CasADi::SymbolicQR >::wrapReturn( CasADi::SymbolicQR(x0_, x1_) );
}


// ================== Constructor method: "SymbolicQR''" ===============
// class: "CasADi::SymbolicQR"
// cppName: "CasADi::SymbolicQR"
// cWrapperName: "CasADi__SymbolicQR__SymbolicQR_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SymbolicQR
// cWrapperRetType: "CasADi::SymbolicQR*"
// proto: "CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::SymbolicQR(x0_)"
extern "C"
    CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR_TIC_TIC(CasADi::Sparsity* x0);
CasADi::SymbolicQR* CasADi__SymbolicQR__SymbolicQR_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::SymbolicQR*, CasADi::SymbolicQR >::wrapReturn( CasADi::SymbolicQR(x0_) );
}


// ================== delete CasadiClass DirectSingleShooting===============
// classType: CasadiClass DirectSingleShooting
extern "C"
    void delete_CasADi__DirectSingleShooting(CasADi::DirectSingleShooting* obj);
void delete_CasADi__DirectSingleShooting(CasADi::DirectSingleShooting* obj){
    delete obj;
}

// ================== Normal method: "getGuess" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::getGuess"
// cWrapperName: "CasADi__DirectSingleShooting__getGuess"
// protoArgs: "(CasADi::DirectSingleShooting* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectSingleShooting__getGuess(CasADi::DirectSingleShooting* obj, std::vector< double >* x0)"
// call: "obj->getGuess(x0_)"
extern "C"
    void CasADi__DirectSingleShooting__getGuess(CasADi::DirectSingleShooting* obj, std::vector< double >* x0);
void CasADi__DirectSingleShooting__getGuess(CasADi::DirectSingleShooting* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->getGuess(x0_);
}


// ================== Normal method: "getVariableBounds" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::getVariableBounds"
// cWrapperName: "CasADi__DirectSingleShooting__getVariableBounds"
// protoArgs: "(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectSingleShooting__getVariableBounds(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// call: "obj->getVariableBounds(x0_, x1_)"
extern "C"
    void CasADi__DirectSingleShooting__getVariableBounds(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1);
void CasADi__DirectSingleShooting__getVariableBounds(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->getVariableBounds(x0_, x1_);
}


// ================== Normal method: "getConstraintBounds" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::getConstraintBounds"
// cWrapperName: "CasADi__DirectSingleShooting__getConstraintBounds"
// protoArgs: "(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectSingleShooting__getConstraintBounds(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// call: "obj->getConstraintBounds(x0_, x1_)"
extern "C"
    void CasADi__DirectSingleShooting__getConstraintBounds(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1);
void CasADi__DirectSingleShooting__getConstraintBounds(CasADi::DirectSingleShooting* obj, std::vector< double >* x0, std::vector< double >* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->getConstraintBounds(x0_, x1_);
}


// ================== Normal method: "setOptimalSolution" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::setOptimalSolution"
// cWrapperName: "CasADi__DirectSingleShooting__setOptimalSolution"
// protoArgs: "(CasADi::DirectSingleShooting* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectSingleShooting__setOptimalSolution(CasADi::DirectSingleShooting* obj, std::vector< double >* x0)"
// call: "obj->setOptimalSolution(x0_)"
extern "C"
    void CasADi__DirectSingleShooting__setOptimalSolution(CasADi::DirectSingleShooting* obj, std::vector< double >* x0);
void CasADi__DirectSingleShooting__setOptimalSolution(CasADi::DirectSingleShooting* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setOptimalSolution(x0_);
}


// ================== Normal method: "getNLPSolver" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::getNLPSolver"
// cWrapperName: "CasADi__DirectSingleShooting__getNLPSolver"
// protoArgs: "(CasADi::DirectSingleShooting* obj)"
// args: "()"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__DirectSingleShooting__getNLPSolver(CasADi::DirectSingleShooting* obj)"
// call: "obj->getNLPSolver()"
extern "C"
    CasADi::NLPSolver* CasADi__DirectSingleShooting__getNLPSolver(CasADi::DirectSingleShooting* obj);
CasADi::NLPSolver* CasADi__DirectSingleShooting__getNLPSolver(CasADi::DirectSingleShooting* obj){

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( obj->getNLPSolver() );
}


// ================== Normal method: "reportConstraints'" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::reportConstraints'"
// cWrapperName: "CasADi__DirectSingleShooting__reportConstraints_TIC"
// protoArgs: "(CasADi::DirectSingleShooting* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectSingleShooting__reportConstraints_TIC(CasADi::DirectSingleShooting* obj)"
// call: "obj->reportConstraints()"
extern "C"
    void CasADi__DirectSingleShooting__reportConstraints_TIC(CasADi::DirectSingleShooting* obj);
void CasADi__DirectSingleShooting__reportConstraints_TIC(CasADi::DirectSingleShooting* obj){

    obj->reportConstraints();
}


// ================== Normal method: "getReportConstraints" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting::getReportConstraints"
// cWrapperName: "CasADi__DirectSingleShooting__getReportConstraints"
// protoArgs: "(CasADi::DirectSingleShooting* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__DirectSingleShooting__getReportConstraints(CasADi::DirectSingleShooting* obj)"
// call: "obj->getReportConstraints()"
extern "C"
    std::string* CasADi__DirectSingleShooting__getReportConstraints(CasADi::DirectSingleShooting* obj);
std::string* CasADi__DirectSingleShooting__getReportConstraints(CasADi::DirectSingleShooting* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getReportConstraints() );
}


// ================== Constructor method: "DirectSingleShooting" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting"
// cWrapperName: "CasADi__DirectSingleShooting__DirectSingleShooting"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DirectSingleShooting
// cWrapperRetType: "CasADi::DirectSingleShooting*"
// proto: "CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting()"
// call: "CasADi::DirectSingleShooting()"
extern "C"
    CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting();
CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting(){

    return WrapReturn< CasADi::DirectSingleShooting*, CasADi::DirectSingleShooting >::wrapReturn( CasADi::DirectSingleShooting() );
}


// ================== Constructor method: "DirectSingleShooting'" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting"
// cWrapperName: "CasADi__DirectSingleShooting__DirectSingleShooting_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass DirectSingleShooting
// cWrapperRetType: "CasADi::DirectSingleShooting*"
// proto: "CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3)"
// call: "CasADi::DirectSingleShooting(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3);
CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Function const & x2_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x2);
    CasADi::Function const & x3_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x3);

    return WrapReturn< CasADi::DirectSingleShooting*, CasADi::DirectSingleShooting >::wrapReturn( CasADi::DirectSingleShooting(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "DirectSingleShooting''" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting"
// cWrapperName: "CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DirectSingleShooting
// cWrapperRetType: "CasADi::DirectSingleShooting*"
// proto: "CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2)"
// call: "CasADi::DirectSingleShooting(x0_, x1_, x2_)"
extern "C"
    CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2);
CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Function const & x2_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x2);

    return WrapReturn< CasADi::DirectSingleShooting*, CasADi::DirectSingleShooting >::wrapReturn( CasADi::DirectSingleShooting(x0_, x1_, x2_) );
}


// ================== Constructor method: "DirectSingleShooting'''" ===============
// class: "CasADi::DirectSingleShooting"
// cppName: "CasADi::DirectSingleShooting"
// cWrapperName: "CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DirectSingleShooting
// cWrapperRetType: "CasADi::DirectSingleShooting*"
// proto: "CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::DirectSingleShooting(x0_, x1_)"
extern "C"
    CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::DirectSingleShooting* CasADi__DirectSingleShooting__DirectSingleShooting_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::DirectSingleShooting*, CasADi::DirectSingleShooting >::wrapReturn( CasADi::DirectSingleShooting(x0_, x1_) );
}


// ================== delete CasadiClass SX===============
// classType: CasadiClass SX
extern "C"
    void delete_CasADi__Matrix_CasADi__SXElement_(CasADi::Matrix< CasADi::SXElement >* obj);
void delete_CasADi__Matrix_CasADi__SXElement_(CasADi::Matrix< CasADi::SXElement >* obj){
    delete obj;
}

// ================== Normal method: "sanityCheck" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sanityCheck"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sanityCheck"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___sanityCheck(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// call: "obj->sanityCheck(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___sanityCheck(CasADi::Matrix< CasADi::SXElement >* obj, int x0);
void CasADi__Matrix_CasADi__SXElement___sanityCheck(CasADi::Matrix< CasADi::SXElement >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->sanityCheck(x0_);
}


// ================== Normal method: "sanityCheck'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sanityCheck'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sanityCheck()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->sanityCheck();
}


// ================== Normal method: "at" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::at"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___at"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___at(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// call: "obj->at(x0_)"
extern "C"
    CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___at(CasADi::Matrix< CasADi::SXElement >* obj, int x0);
CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___at(CasADi::Matrix< CasADi::SXElement >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->at(x0_) );
}


// ================== Normal method: "elem" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::elem"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___elem"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___elem(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// call: "obj->elem(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___elem(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1);
CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___elem(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->elem(x0_, x1_) );
}


// ================== Normal method: "elem'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::elem'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___elem_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___elem_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// call: "obj->elem(x0_)"
extern "C"
    CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___elem_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0);
CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___elem_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( obj->elem(x0_) );
}


// ================== Normal method: "hasNZ" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::hasNZ"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___hasNZ"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___hasNZ(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___hasNZ(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1);
int CasADi__Matrix_CasADi__SXElement___hasNZ(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( obj->hasNZ(x0_, x1_) );
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__nonzero__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____nonzero__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement_____nonzero__(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->__nonzero__()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement_____nonzero__(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement_____nonzero__(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->__nonzero__() );
}


// ================== Normal method: "setSub" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
void CasADi__Matrix_CasADi__SXElement___setSub(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, int x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::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_);
}


// ================== Normal method: "setSub''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, std::vector< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1, std::vector< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::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_);
}


// ================== Normal method: "setSub'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::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_);
}


// ================== Normal method: "setSub''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, std::vector< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, std::vector< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Slice* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Slice* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Slice* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Slice* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    std::vector< int > x2_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Slice* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Slice const & x2_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub''''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'''''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int > const & x2_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub''''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub''''''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, int x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Slice* x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setSub'''''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSub'''''''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1, int x2)"
// call: "obj->setSub(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1, int x2);
void CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setSub(x0_, x1_, x2_);
}


// ================== Normal method: "setNZ" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setNZ"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setNZ"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setNZ(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setNZ(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___setNZ(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::Matrix< CasADi::SXElement >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setNZ'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setNZ_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setNZ_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setNZ_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___setNZ_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setNZ''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "setNZ'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setNZ'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setNZ(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setNZ(x0_, x1_);
}


// ================== Normal method: "append" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::append"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___append"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___append(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->append(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___append(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__Matrix_CasADi__SXElement___append(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    obj->append(x0_);
}


// ================== Normal method: "appendColumns" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::appendColumns"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___appendColumns"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___appendColumns(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->appendColumns(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___appendColumns(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__Matrix_CasADi__SXElement___appendColumns(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    obj->appendColumns(x0_);
}


// ================== Normal method: "nz_indexed_one_based_assignment" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nz_indexed_one_based_assignment"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1);
void CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_zero_based_assignment" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nz_indexed_zero_based_assignment"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1);
void CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nz_indexed_assignment"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_one_based_assignment"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_zero_based_assignment"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_one_based_assignment'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nz_indexed_one_based_assignment'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->nz_indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->nz_indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_zero_based_assignment'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nz_indexed_zero_based_assignment'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->nz_indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->nz_indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "nz_indexed_assignment'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nz_indexed_assignment'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->nz_indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->nz_indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_one_based_assignment'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2)"
// call: "obj->indexed_one_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    CasADi::SXElement const & x2_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x2);

    obj->indexed_one_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_zero_based_assignment'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_zero_based_assignment'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, CasADi::SXElement* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    CasADi::SXElement const & x2_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x2);

    obj->indexed_zero_based_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Slice* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Slice const & x1_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::IndexList* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::IndexList const & x1_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment'''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "obj->indexed_assignment(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    obj->indexed_assignment(x0_, x1_, x2_);
}


// ================== Normal method: "indexed_assignment'''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment'''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_one_based_assignment''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_one_based_assignment''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// call: "obj->indexed_one_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    obj->indexed_one_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_zero_based_assignment''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_zero_based_assignment''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1)"
// call: "obj->indexed_zero_based_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, CasADi::SXElement* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    obj->indexed_zero_based_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Slice* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "indexed_assignment'''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::indexed_assignment'''''''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->indexed_assignment(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::IndexList* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::IndexList const & x0_ = Marshaling<CasADi::IndexList const &,CasADi::IndexList*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->indexed_assignment(x0_, x1_);
}


// ================== Normal method: "setZero" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setZero"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setZero"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setZero(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->setZero()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setZero(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___setZero(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->setZero();
}


// ================== Normal method: "setAll" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setAll"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setAll"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setAll(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->setAll(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setAll(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0);
void CasADi__Matrix_CasADi__SXElement___setAll(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    obj->setAll(x0_);
}


// ================== Normal method: "setSparse" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSparse"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSparse"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___setSparse(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, int x1)"
// call: "obj->setSparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___setSparse(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___setSparse(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->setSparse(x0_, x1_) );
}


// ================== Normal method: "setSparse'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setSparse'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setSparse_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___setSparse_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0)"
// call: "obj->setSparse(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___setSparse_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___setSparse_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->setSparse(x0_) );
}


// ================== Normal method: "densify" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::densify"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___densify"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___densify(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->densify(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___densify(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0);
void CasADi__Matrix_CasADi__SXElement___densify(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    obj->densify(x0_);
}


// ================== Normal method: "densify'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::densify'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___densify_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___densify_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->densify()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___densify_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___densify_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->densify();
}


// ================== Normal method: "sparsify" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sparsify"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sparsify"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___sparsify(CasADi::Matrix< CasADi::SXElement >* obj, double x0)"
// call: "obj->sparsify(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___sparsify(CasADi::Matrix< CasADi::SXElement >* obj, double x0);
void CasADi__Matrix_CasADi__SXElement___sparsify(CasADi::Matrix< CasADi::SXElement >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->sparsify(x0_);
}


// ================== Normal method: "sparsify'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sparsify'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sparsify_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___sparsify_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sparsify()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___sparsify_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___sparsify_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->sparsify();
}


// ================== Normal method: "operator +" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::operator +"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___operator_plus"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___operator_plus(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->operator +()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___operator_plus(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___operator_plus(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->operator +() );
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::operator -"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___operator_minus"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___operator_minus(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___operator_minus(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___operator_minus(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->operator -() );
}


// ================== Static method: "binary" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::binary"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___binary"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___binary(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___binary(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___binary(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::binary(x0_, x1_, x2_) );
}


// ================== Static method: "unary" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::unary"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___unary"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___unary(int x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::unary(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___unary(int x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___unary(int x0, CasADi::Matrix< CasADi::SXElement >* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::unary(x0_, x1_) );
}


// ================== Static method: "scalar_matrix" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::scalar_matrix"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___scalar_matrix"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___scalar_matrix(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::scalar_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___scalar_matrix(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___scalar_matrix(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::scalar_matrix(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_scalar" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::matrix_scalar"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___matrix_scalar"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___matrix_scalar(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::matrix_scalar(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___matrix_scalar(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___matrix_scalar(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::matrix_scalar(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_matrix" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::matrix_matrix"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___matrix_matrix"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___matrix_matrix(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::matrix_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___matrix_matrix(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___matrix_matrix(int x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::matrix_matrix(x0_, x1_, x2_) );
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__add__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____add__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____add__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____add__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____add__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__sub__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____sub__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____sub__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____sub__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____sub__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__mul__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____mul__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mul__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mul__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mul__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__div__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____div__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____div__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____div__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____div__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__lt__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____lt__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____lt__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____lt__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____lt__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__le__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____le__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____le__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____le__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____le__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__eq__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____eq__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____eq__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____eq__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____eq__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__ne__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____ne__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____ne__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____ne__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____ne__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__truediv__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____truediv__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____truediv__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____truediv__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____truediv__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__pow__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____pow__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____pow__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____pow__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____pow__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__constpow__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____constpow__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____constpow__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____constpow__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____constpow__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__mpower__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____mpower__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mpower__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mpower__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mpower__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__mpower__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__mrdivide__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____mrdivide__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mrdivide__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mrdivide__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____mrdivide__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "mul_full" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_full"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_full"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_full(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_full(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_full(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->mul_full(x0_, x1_) );
}


// ================== Normal method: "mul_full'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_full'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_full_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_full_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->mul_full(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_full_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_full_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->mul_full(x0_) );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->mul(x0_, x1_) );
}


// ================== Normal method: "mul'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___mul_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->mul(x0_) );
}


// ================== Static method: "mul_no_alloc_nn" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nn"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement >& x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_tn" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_tn"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement >& x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_tn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_nt" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nt"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nt(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement >& x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nt(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_tn'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_tn'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2);
void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);

    CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_tn(x0_, x1_, x2_);
}


// ================== Static method: "mul_no_alloc_nn'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nn'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2);
void CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);

    CasADi::Matrix< CasADi::SXElement >::mul_no_alloc_nn(x0_, x1_, x2_);
}


// ================== Static method: "quad_form" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::quad_form"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___quad_form"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SXElement
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___quad_form(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::quad_form(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___quad_form(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1);
CasADi::SXElement* CasADi__Matrix_CasADi__SXElement___quad_form(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::quad_form(x0_, x1_) );
}


// ================== Normal method: "trans" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::trans"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___trans"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___trans(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___trans(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___trans(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->trans() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sin"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sin"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sin(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sin(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sin(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::cos"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___cos"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___cos(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___cos(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___cos(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::tan"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___tan"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___tan(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___tan(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___tan(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arcsin"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arcsin"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arcsin(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arcsin(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arcsin(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arccos"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arccos"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arccos(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arccos(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arccos(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arctan"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arctan"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctan(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctan(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctan(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arctan() );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::exp"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___exp"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___exp(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___exp(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___exp(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::log"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___log"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___log(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->log()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___log(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___log(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->log() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sqrt"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sqrt"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sqrt(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sqrt(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sqrt(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->sqrt() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::floor"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___floor"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___floor(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___floor(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___floor(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::ceil"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___ceil"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___ceil(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___ceil(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___ceil(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->ceil() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::fabs"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___fabs"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fabs(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fabs(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fabs(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->fabs() );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sign"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sign"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sign(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sign(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sign(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->sign() );
}


// ================== Normal method: "__copysign__" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::__copysign__"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement_____copysign__"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____copysign__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->__copysign__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____copysign__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement_____copysign__(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->__copysign__(x0_) );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::erfinv"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___erfinv"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___erfinv(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___erfinv(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___erfinv(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->erfinv() );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::fmin"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___fmin"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fmin(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fmin(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fmin(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::fmax"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___fmax"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fmax(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fmax(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___fmax(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->fmax(x0_) );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::erf"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___erf"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___erf(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___erf(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___erf(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->erf() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sinh"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sinh"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sinh(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sinh(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___sinh(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::cosh"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___cosh"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___cosh(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___cosh(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___cosh(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::tanh"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___tanh"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___tanh(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___tanh(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___tanh(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arcsinh"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arcsinh"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arcsinh(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arcsinh(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arcsinh(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arccosh"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arccosh"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arccosh(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arccosh(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arccosh(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arctanh"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arctanh"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctanh(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctanh(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctanh(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arctanh() );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::arctan2"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___arctan2"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctan2(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctan2(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___arctan2(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->arctan2(x0_) );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::log10"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___log10"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___log10(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___log10(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___log10(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->log10() );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::printme"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___printme"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___printme(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___printme(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___printme(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->printme(x0_) );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::logic_not"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___logic_not"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_not(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_not(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_not(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->logic_not() );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::logic_and"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___logic_and"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_and(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_and(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_and(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::logic_or"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___logic_or"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_or(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_or(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___logic_or(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::if_else_zero"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___if_else_zero"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___if_else_zero(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___if_else_zero(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___if_else_zero(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->if_else_zero(x0_) );
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setMaxNumCallsInPrint"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint"
// protoArgs: "(long x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint(long x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::setMaxNumCallsInPrint(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint(long x0);
void CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint(long x0){
    long x0_ = Marshaling<long,long>::marshal(x0);

    CasADi::Matrix< CasADi::SXElement >::setMaxNumCallsInPrint(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setMaxNumCallsInPrint'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC()"
// call: "CasADi::Matrix< CasADi::SXElement >::setMaxNumCallsInPrint()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC();
void CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC(){

    CasADi::Matrix< CasADi::SXElement >::setMaxNumCallsInPrint();
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::getMaxNumCallsInPrint"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint"
// protoArgs: "()"
// args: "()"
// rettype: CLong
// cWrapperRetType: "long"
// proto: "long CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint()"
// call: "CasADi::Matrix< CasADi::SXElement >::getMaxNumCallsInPrint()"
extern "C"
    long CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint();
long CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint(){

    return WrapReturn< long, long >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::getMaxNumCallsInPrint() );
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setEqualityCheckingDepth"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::setEqualityCheckingDepth(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth(int x0);
void CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< CasADi::SXElement >::setEqualityCheckingDepth(x0_);
}


// ================== Static method: "setEqualityCheckingDepth'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setEqualityCheckingDepth'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC()"
// call: "CasADi::Matrix< CasADi::SXElement >::setEqualityCheckingDepth()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC();
void CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC(){

    CasADi::Matrix< CasADi::SXElement >::setEqualityCheckingDepth();
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::getEqualityCheckingDepth"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth"
// protoArgs: "()"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth()"
// call: "CasADi::Matrix< CasADi::SXElement >::getEqualityCheckingDepth()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth();
int CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth(){

    return WrapReturn< int, int >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::getEqualityCheckingDepth() );
}


// ================== Static method: "className" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::className"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___className"
// protoArgs: "()"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Matrix_CasADi__SXElement___className()"
// call: "CasADi::Matrix< CasADi::SXElement >::className()"
extern "C"
    std::string* CasADi__Matrix_CasADi__SXElement___className();
std::string* CasADi__Matrix_CasADi__SXElement___className(){

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::className() );
}


// ================== Normal method: "printScalar'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::printScalar'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___printScalar_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___printScalar_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->printScalar()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___printScalar_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___printScalar_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->printScalar();
}


// ================== Normal method: "printVector'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::printVector'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___printVector_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___printVector_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->printVector()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___printVector_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___printVector_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->printVector();
}


// ================== Normal method: "printDense'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::printDense'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___printDense_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___printDense_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->printDense()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___printDense_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___printDense_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->printDense();
}


// ================== Normal method: "printSparse'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::printSparse'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___printSparse_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___printSparse_TIC(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->printSparse()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___printSparse_TIC(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___printSparse_TIC(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->printSparse();
}


// ================== Normal method: "row" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::row"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___row"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___row(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// call: "obj->row(x0_)"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___row(CasADi::Matrix< CasADi::SXElement >* obj, int x0);
int CasADi__Matrix_CasADi__SXElement___row(CasADi::Matrix< CasADi::SXElement >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->row(x0_) );
}


// ================== Normal method: "colind" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::colind"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___colind"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___colind(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// call: "obj->colind(x0_)"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___colind(CasADi::Matrix< CasADi::SXElement >* obj, int x0);
int CasADi__Matrix_CasADi__SXElement___colind(CasADi::Matrix< CasADi::SXElement >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->colind(x0_) );
}


// ================== Normal method: "clear" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::clear"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___clear"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___clear(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->clear()"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___clear(CasADi::Matrix< CasADi::SXElement >* obj);
void CasADi__Matrix_CasADi__SXElement___clear(CasADi::Matrix< CasADi::SXElement >* obj){

    obj->clear();
}


// ================== Normal method: "resize" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::resize"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___resize"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___resize(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___resize(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1);
void CasADi__Matrix_CasADi__SXElement___resize(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->resize(x0_, x1_);
}


// ================== Normal method: "reserve" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::reserve"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___reserve"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___reserve(CasADi::Matrix< CasADi::SXElement >* obj, int x0)"
// call: "obj->reserve(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___reserve(CasADi::Matrix< CasADi::SXElement >* obj, int x0);
void CasADi__Matrix_CasADi__SXElement___reserve(CasADi::Matrix< CasADi::SXElement >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->reserve(x0_);
}


// ================== Normal method: "reserve'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::reserve'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___reserve_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___reserve_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___reserve_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1);
void CasADi__Matrix_CasADi__SXElement___reserve_TIC(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->reserve(x0_, x1_);
}


// ================== Normal method: "erase" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::erase"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___erase"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___erase(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->erase(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___erase(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Matrix_CasADi__SXElement___erase(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "remove" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::remove"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___remove"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___remove(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1)"
// call: "obj->remove(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___remove(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1);
void CasADi__Matrix_CasADi__SXElement___remove(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< int >* x0, std::vector< int >* x1){
    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_);
}


// ================== Normal method: "enlarge" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::enlarge"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___enlarge"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* 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__Matrix_CasADi__SXElement___enlarge(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "obj->enlarge(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___enlarge(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
void CasADi__Matrix_CasADi__SXElement___enlarge(CasADi::Matrix< CasADi::SXElement >* obj, int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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_);
}


// ================== Normal method: "data" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::data"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___data"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: StdVec (CasadiClass SXElement)
// cWrapperRetType: "std::vector< CasADi::SXElement* >*"
// proto: "std::vector< CasADi::SXElement* >* CasADi__Matrix_CasADi__SXElement___data(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->data()"
extern "C"
    std::vector< CasADi::SXElement* >* CasADi__Matrix_CasADi__SXElement___data(CasADi::Matrix< CasADi::SXElement >* obj);
std::vector< CasADi::SXElement* >* CasADi__Matrix_CasADi__SXElement___data(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< std::vector< CasADi::SXElement* >*, std::vector< CasADi::SXElement > >::wrapReturn( obj->data() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::sparsityRef"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___sparsityRef"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Matrix_CasADi__SXElement___sparsityRef(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__Matrix_CasADi__SXElement___sparsityRef(CasADi::Matrix< CasADi::SXElement >* obj);
CasADi::Sparsity* CasADi__Matrix_CasADi__SXElement___sparsityRef(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Normal method: "set" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::set"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___set"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___set(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___set(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1);
void CasADi__Matrix_CasADi__SXElement___set(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1){
    CasADi::SXElement x0_ = Marshaling<CasADi::SXElement,CasADi::SXElement*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::set'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___set_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___set_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___set_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0);
void CasADi__Matrix_CasADi__SXElement___set_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement x0_ = Marshaling<CasADi::SXElement,CasADi::SXElement*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::get"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___get"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___get(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___get(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1);
void CasADi__Matrix_CasADi__SXElement___get(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0, CasADi::SparsityType x1){
    CasADi::SXElement& x0_ = Marshaling<CasADi::SXElement&,CasADi::SXElement*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::get'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___get_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___get_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___get_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0);
void CasADi__Matrix_CasADi__SXElement___get_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::SXElement* x0){
    CasADi::SXElement& x0_ = Marshaling<CasADi::SXElement&,CasADi::SXElement*>::marshal(x0);

    obj->get(x0_);
}


// ================== Normal method: "set''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::set''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::set'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0);
void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::get''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0, CasADi::SparsityType x1){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::get'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0);
void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, std::vector< CasADi::SXElement* >* x0){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);

    obj->get(x0_);
}


// ================== Normal method: "set''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::set''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->set(x0_, x1_);
}


// ================== Normal method: "set'''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::set'''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    obj->set(x0_);
}


// ================== Normal method: "get''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::get''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1);
void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::SparsityType x1){
    CasADi::Matrix< CasADi::SXElement >& x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::SparsityType x1_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x1);

    obj->get(x0_, x1_);
}


// ================== Normal method: "get'''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::get'''''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement >& x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    obj->get(x0_);
}


// ================== Static method: "triplet" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::triplet"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___triplet"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::triplet(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___triplet(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2){
    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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::triplet(x0_, x1_, x2_) );
}


// ================== Static method: "triplet'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::triplet'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___triplet_TIC"
// protoArgs: "(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2, int x3, int x4)"
// call: "CasADi::Matrix< CasADi::SXElement >::triplet(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2, int x3, int x4);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___triplet_TIC(std::vector< int >* x0, std::vector< int >* x1, std::vector< CasADi::SXElement* >* x2, int x3, int x4){
    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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::triplet(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::inf"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___inf"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::inf(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf(CasADi::Sparsity* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::inf(x0_) );
}


// ================== Static method: "inf'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::inf'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___inf_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC(int x0, int x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::inf(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC(int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::inf(x0_, x1_) );
}


// ================== Static method: "inf''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::inf''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::inf(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC(int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::inf(x0_) );
}


// ================== Static method: "inf'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::inf'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC()"
// call: "CasADi::Matrix< CasADi::SXElement >::inf()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC();
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nan"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nan"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::nan(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan(CasADi::Sparsity* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::nan(x0_) );
}


// ================== Static method: "nan'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nan'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nan_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC(int x0, int x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::nan(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC(int x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::nan(x0_, x1_) );
}


// ================== Static method: "nan''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nan''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::nan(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC(int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::nan(x0_) );
}


// ================== Static method: "nan'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::nan'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC()"
// call: "CasADi::Matrix< CasADi::SXElement >::nan()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC();
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::repmat"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___repmat"
// protoArgs: "(CasADi::SXElement* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat(CasADi::SXElement* x0, CasADi::Sparsity* x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat(CasADi::SXElement* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat(CasADi::SXElement* x0, CasADi::Sparsity* x1){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_) );
}


// ================== Static method: "repmat'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::repmat'"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___repmat_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_) );
}


// ================== Static method: "repmat''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::repmat''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_, x2_) );
}


// ================== Static method: "repmat'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::repmat'''"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::repmat(x0_, x1_) );
}


// ================== Static method: "eye" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::eye"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___eye"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___eye(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::eye(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___eye(int x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___eye(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >::eye(x0_) );
}


// ================== Normal method: "isRegular" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isRegular"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isRegular"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isRegular(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isRegular()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isRegular(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isRegular(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isRegular() );
}


// ================== Normal method: "isSmooth" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isSmooth"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isSmooth"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isSmooth(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isSmooth()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isSmooth(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isSmooth(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSmooth() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isSymbolic"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isSymbolic"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isSymbolic(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isSymbolic()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isSymbolic(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isSymbolic(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolic() );
}


// ================== Normal method: "isSymbolicSparse" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isSymbolicSparse"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isSymbolicSparse"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isSymbolicSparse(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isSymbolicSparse()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isSymbolicSparse(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isSymbolicSparse(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSymbolicSparse() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isConstant"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isConstant"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isConstant(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isConstant()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isConstant(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isConstant(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isConstant() );
}


// ================== Normal method: "isInteger" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isInteger"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isInteger"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isInteger(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isInteger()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isInteger(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isInteger(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isInteger() );
}


// ================== Normal method: "isZero" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isZero"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isZero"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isZero(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isZero()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isZero(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isZero(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isZero() );
}


// ================== Normal method: "isOne" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isOne"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isOne"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isOne(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isOne()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isOne(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isOne(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isOne() );
}


// ================== Normal method: "isMinusOne" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isMinusOne"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isMinusOne"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isMinusOne(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isMinusOne()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isMinusOne(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isMinusOne(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isMinusOne() );
}


// ================== Normal method: "isIdentity" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isIdentity"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isIdentity"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isIdentity(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->isIdentity()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isIdentity(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___isIdentity(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isIdentity() );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::isEqual"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___isEqual"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___isEqual(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___isEqual(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0);
int CasADi__Matrix_CasADi__SXElement___isEqual(CasADi::Matrix< CasADi::SXElement >* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEqual(x0_) );
}


// ================== Normal method: "hasNonStructuralZeros" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::hasNonStructuralZeros"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->hasNonStructuralZeros()"
extern "C"
    int CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros(CasADi::Matrix< CasADi::SXElement >* obj);
int CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->hasNonStructuralZeros() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::getValue"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___getValue"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__Matrix_CasADi__SXElement___getValue(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->getValue()"
extern "C"
    double CasADi__Matrix_CasADi__SXElement___getValue(CasADi::Matrix< CasADi::SXElement >* obj);
double CasADi__Matrix_CasADi__SXElement___getValue(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< double, double >::wrapReturn( obj->getValue() );
}


// ================== Normal method: "getName" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::getName"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___getName"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Matrix_CasADi__SXElement___getName(CasADi::Matrix< CasADi::SXElement >* obj)"
// call: "obj->getName()"
extern "C"
    std::string* CasADi__Matrix_CasADi__SXElement___getName(CasADi::Matrix< CasADi::SXElement >* obj);
std::string* CasADi__Matrix_CasADi__SXElement___getName(CasADi::Matrix< CasADi::SXElement >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getName() );
}


// ================== Static method: "setPrecision" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setPrecision"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setPrecision"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setPrecision(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::setPrecision(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setPrecision(int x0);
void CasADi__Matrix_CasADi__SXElement___setPrecision(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< CasADi::SXElement >::setPrecision(x0_);
}


// ================== Static method: "setWidth" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setWidth"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setWidth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setWidth(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::setWidth(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setWidth(int x0);
void CasADi__Matrix_CasADi__SXElement___setWidth(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    CasADi::Matrix< CasADi::SXElement >::setWidth(x0_);
}


// ================== Static method: "setScientific" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >::setScientific"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___setScientific"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SXElement___setScientific(int x0)"
// call: "CasADi::Matrix< CasADi::SXElement >::setScientific(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SXElement___setScientific(int x0);
void CasADi__Matrix_CasADi__SXElement___setScientific(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    CasADi::Matrix< CasADi::SXElement >::setScientific(x0_);
}


// ================== Constructor method: "SX" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX()"
// call: "CasADi::Matrix< CasADi::SXElement >()"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX();
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX(){

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >() );
}


// ================== Constructor method: "SX'" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC"
// protoArgs: "(std::vector< std::vector< CasADi::SXElement* >* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC(std::vector< std::vector< CasADi::SXElement* >* >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC(std::vector< std::vector< CasADi::SXElement* >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC(std::vector< std::vector< CasADi::SXElement* >* >* x0){
    std::vector< std::vector< CasADi::SXElement > > x0_ = Marshaling<std::vector< std::vector< CasADi::SXElement > >,std::vector< std::vector< CasADi::SXElement* >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX'''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, CasADi::SXElement* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::SXElement* x1)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::SXElement* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::SXElement* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_, x1_) );
}


// ================== Constructor method: "SX''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX'''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, std::vector< CasADi::SXElement* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< CasADi::SXElement* >* x1)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< CasADi::SXElement* >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< CasADi::SXElement* >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_, x1_) );
}


// ================== Constructor method: "SX''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC(double x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC(double x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX'''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::SXElement* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::SXElement* >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::SXElement* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::SXElement* >* x0){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::SXElement* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::SXElement* >* x0, int x1, int x2)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::SXElement* >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::SXElement* >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_, x1_, x2_) );
}


// ================== Constructor method: "SX'''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX'''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< int >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< int >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_, x1_, x2_) );
}


// ================== Constructor method: "SX''''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX'''''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_) );
}


// ================== Constructor method: "SX''''''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SXElement >"
// cppName: "CasADi::Matrix< CasADi::SXElement >"
// cWrapperName: "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0, int x1, int x2)"
// call: "CasADi::Matrix< CasADi::SXElement >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< double >* x0, int x1, int x2){
    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);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::Matrix< CasADi::SXElement >(x0_, x1_, x2_) );
}


// ================== delete CasadiClass DirectMultipleShooting===============
// classType: CasadiClass DirectMultipleShooting
extern "C"
    void delete_CasADi__DirectMultipleShooting(CasADi::DirectMultipleShooting* obj);
void delete_CasADi__DirectMultipleShooting(CasADi::DirectMultipleShooting* obj){
    delete obj;
}

// ================== Normal method: "getGuess" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::getGuess"
// cWrapperName: "CasADi__DirectMultipleShooting__getGuess"
// protoArgs: "(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectMultipleShooting__getGuess(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0)"
// call: "obj->getGuess(x0_)"
extern "C"
    void CasADi__DirectMultipleShooting__getGuess(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0);
void CasADi__DirectMultipleShooting__getGuess(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->getGuess(x0_);
}


// ================== Normal method: "getVariableBounds" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::getVariableBounds"
// cWrapperName: "CasADi__DirectMultipleShooting__getVariableBounds"
// protoArgs: "(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectMultipleShooting__getVariableBounds(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// call: "obj->getVariableBounds(x0_, x1_)"
extern "C"
    void CasADi__DirectMultipleShooting__getVariableBounds(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1);
void CasADi__DirectMultipleShooting__getVariableBounds(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->getVariableBounds(x0_, x1_);
}


// ================== Normal method: "getConstraintBounds" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::getConstraintBounds"
// cWrapperName: "CasADi__DirectMultipleShooting__getConstraintBounds"
// protoArgs: "(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectMultipleShooting__getConstraintBounds(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1)"
// call: "obj->getConstraintBounds(x0_, x1_)"
extern "C"
    void CasADi__DirectMultipleShooting__getConstraintBounds(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1);
void CasADi__DirectMultipleShooting__getConstraintBounds(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0, std::vector< double >* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->getConstraintBounds(x0_, x1_);
}


// ================== Normal method: "setOptimalSolution" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::setOptimalSolution"
// cWrapperName: "CasADi__DirectMultipleShooting__setOptimalSolution"
// protoArgs: "(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectMultipleShooting__setOptimalSolution(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0)"
// call: "obj->setOptimalSolution(x0_)"
extern "C"
    void CasADi__DirectMultipleShooting__setOptimalSolution(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0);
void CasADi__DirectMultipleShooting__setOptimalSolution(CasADi::DirectMultipleShooting* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setOptimalSolution(x0_);
}


// ================== Normal method: "getNLPSolver" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::getNLPSolver"
// cWrapperName: "CasADi__DirectMultipleShooting__getNLPSolver"
// protoArgs: "(CasADi::DirectMultipleShooting* obj)"
// args: "()"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__DirectMultipleShooting__getNLPSolver(CasADi::DirectMultipleShooting* obj)"
// call: "obj->getNLPSolver()"
extern "C"
    CasADi::NLPSolver* CasADi__DirectMultipleShooting__getNLPSolver(CasADi::DirectMultipleShooting* obj);
CasADi::NLPSolver* CasADi__DirectMultipleShooting__getNLPSolver(CasADi::DirectMultipleShooting* obj){

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( obj->getNLPSolver() );
}


// ================== Normal method: "reportConstraints'" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::reportConstraints'"
// cWrapperName: "CasADi__DirectMultipleShooting__reportConstraints_TIC"
// protoArgs: "(CasADi::DirectMultipleShooting* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__DirectMultipleShooting__reportConstraints_TIC(CasADi::DirectMultipleShooting* obj)"
// call: "obj->reportConstraints()"
extern "C"
    void CasADi__DirectMultipleShooting__reportConstraints_TIC(CasADi::DirectMultipleShooting* obj);
void CasADi__DirectMultipleShooting__reportConstraints_TIC(CasADi::DirectMultipleShooting* obj){

    obj->reportConstraints();
}


// ================== Normal method: "getReportConstraints" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting::getReportConstraints"
// cWrapperName: "CasADi__DirectMultipleShooting__getReportConstraints"
// protoArgs: "(CasADi::DirectMultipleShooting* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__DirectMultipleShooting__getReportConstraints(CasADi::DirectMultipleShooting* obj)"
// call: "obj->getReportConstraints()"
extern "C"
    std::string* CasADi__DirectMultipleShooting__getReportConstraints(CasADi::DirectMultipleShooting* obj);
std::string* CasADi__DirectMultipleShooting__getReportConstraints(CasADi::DirectMultipleShooting* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->getReportConstraints() );
}


// ================== Constructor method: "DirectMultipleShooting" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting"
// cWrapperName: "CasADi__DirectMultipleShooting__DirectMultipleShooting"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DirectMultipleShooting
// cWrapperRetType: "CasADi::DirectMultipleShooting*"
// proto: "CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting()"
// call: "CasADi::DirectMultipleShooting()"
extern "C"
    CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting();
CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting(){

    return WrapReturn< CasADi::DirectMultipleShooting*, CasADi::DirectMultipleShooting >::wrapReturn( CasADi::DirectMultipleShooting() );
}


// ================== Constructor method: "DirectMultipleShooting'" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting"
// cWrapperName: "CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass DirectMultipleShooting
// cWrapperRetType: "CasADi::DirectMultipleShooting*"
// proto: "CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3)"
// call: "CasADi::DirectMultipleShooting(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3);
CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2, CasADi::Function* x3){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Function const & x2_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x2);
    CasADi::Function const & x3_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x3);

    return WrapReturn< CasADi::DirectMultipleShooting*, CasADi::DirectMultipleShooting >::wrapReturn( CasADi::DirectMultipleShooting(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "DirectMultipleShooting''" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting"
// cWrapperName: "CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DirectMultipleShooting
// cWrapperRetType: "CasADi::DirectMultipleShooting*"
// proto: "CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2)"
// call: "CasADi::DirectMultipleShooting(x0_, x1_, x2_)"
extern "C"
    CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2);
CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1, CasADi::Function* x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);
    CasADi::Function const & x2_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x2);

    return WrapReturn< CasADi::DirectMultipleShooting*, CasADi::DirectMultipleShooting >::wrapReturn( CasADi::DirectMultipleShooting(x0_, x1_, x2_) );
}


// ================== Constructor method: "DirectMultipleShooting'''" ===============
// class: "CasADi::DirectMultipleShooting"
// cppName: "CasADi::DirectMultipleShooting"
// cWrapperName: "CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DirectMultipleShooting
// cWrapperRetType: "CasADi::DirectMultipleShooting*"
// proto: "CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::DirectMultipleShooting(x0_, x1_)"
extern "C"
    CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::DirectMultipleShooting* CasADi__DirectMultipleShooting__DirectMultipleShooting_TIC_TIC_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::DirectMultipleShooting*, CasADi::DirectMultipleShooting >::wrapReturn( CasADi::DirectMultipleShooting(x0_, x1_) );
}


// ================== delete CasadiClass IOInterfaceFunction===============
// classType: CasadiClass IOInterfaceFunction
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: "input" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::input"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___input"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// call: "obj->input(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input(CasADi::IOInterface< CasADi::Function >* obj, int x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input(CasADi::IOInterface< CasADi::Function >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->input(x0_) );
}


// ================== Normal method: "input'" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::input'"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___input_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input_TIC(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->input()"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input_TIC(CasADi::IOInterface< CasADi::Function >* obj);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input_TIC(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->input() );
}


// ================== Normal method: "input''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::input''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___input_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// call: "obj->input(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___input_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->input(x0_) );
}


// ================== Normal method: "output" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::output"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___output"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// call: "obj->output(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output(CasADi::IOInterface< CasADi::Function >* obj, int x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output(CasADi::IOInterface< CasADi::Function >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->output(x0_) );
}


// ================== Normal method: "output'" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::output'"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___output_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output_TIC(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->output()"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output_TIC(CasADi::IOInterface< CasADi::Function >* obj);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output_TIC(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->output() );
}


// ================== Normal method: "output''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::output''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___output_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// call: "obj->output(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___output_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->output(x0_) );
}


// ================== Normal method: "getNumInputs" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getNumInputs"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getNumInputs"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__Function___getNumInputs(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->getNumInputs()"
extern "C"
    int CasADi__IOInterface_CasADi__Function___getNumInputs(CasADi::IOInterface< CasADi::Function >* obj);
int CasADi__IOInterface_CasADi__Function___getNumInputs(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumInputs() );
}


// ================== Normal method: "getNumOutputs" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getNumOutputs"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getNumOutputs"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__Function___getNumOutputs(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->getNumOutputs()"
extern "C"
    int CasADi__IOInterface_CasADi__Function___getNumOutputs(CasADi::IOInterface< CasADi::Function >* obj);
int CasADi__IOInterface_CasADi__Function___getNumOutputs(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumOutputs() );
}


// ================== Normal method: "setNumInputs" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setNumInputs"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setNumInputs"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setNumInputs(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// call: "obj->setNumInputs(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setNumInputs(CasADi::IOInterface< CasADi::Function >* obj, int x0);
void CasADi__IOInterface_CasADi__Function___setNumInputs(CasADi::IOInterface< CasADi::Function >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setNumInputs(x0_);
}


// ================== Normal method: "setNumOutputs" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setNumOutputs"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setNumOutputs"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setNumOutputs(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// call: "obj->setNumOutputs(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setNumOutputs(CasADi::IOInterface< CasADi::Function >* obj, int x0);
void CasADi__IOInterface_CasADi__Function___setNumOutputs(CasADi::IOInterface< CasADi::Function >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    obj->setNumOutputs(x0_);
}


// ================== Normal method: "setInputScheme" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInputScheme"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInputScheme"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInputScheme(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0)"
// call: "obj->setInputScheme(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInputScheme(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0);
void CasADi__IOInterface_CasADi__Function___setInputScheme(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0){
    CasADi::IOScheme const & x0_ = Marshaling<CasADi::IOScheme const &,CasADi::IOScheme*>::marshal(x0);

    obj->setInputScheme(x0_);
}


// ================== Normal method: "setOutputScheme" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutputScheme"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutputScheme"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutputScheme(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0)"
// call: "obj->setOutputScheme(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutputScheme(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0);
void CasADi__IOInterface_CasADi__Function___setOutputScheme(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0){
    CasADi::IOScheme const & x0_ = Marshaling<CasADi::IOScheme const &,CasADi::IOScheme*>::marshal(x0);

    obj->setOutputScheme(x0_);
}


// ================== Normal method: "getInputScheme" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getInputScheme"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getInputScheme"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOInterface_CasADi__Function___getInputScheme(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->getInputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__IOInterface_CasADi__Function___getInputScheme(CasADi::IOInterface< CasADi::Function >* obj);
CasADi::IOScheme* CasADi__IOInterface_CasADi__Function___getInputScheme(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( obj->getInputScheme() );
}


// ================== Normal method: "getOutputScheme" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getOutputScheme"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getOutputScheme"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOInterface_CasADi__Function___getOutputScheme(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->getOutputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__IOInterface_CasADi__Function___getOutputScheme(CasADi::IOInterface< CasADi::Function >* obj);
CasADi::IOScheme* CasADi__IOInterface_CasADi__Function___getOutputScheme(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( obj->getOutputScheme() );
}


// ================== Normal method: "inputSchemeEntry" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::inputSchemeEntry"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___inputSchemeEntry"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__Function___inputSchemeEntry(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// call: "obj->inputSchemeEntry(x0_)"
extern "C"
    int CasADi__IOInterface_CasADi__Function___inputSchemeEntry(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0);
int CasADi__IOInterface_CasADi__Function___inputSchemeEntry(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->inputSchemeEntry(x0_) );
}


// ================== Normal method: "outputSchemeEntry" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::outputSchemeEntry"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___outputSchemeEntry"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__Function___outputSchemeEntry(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// call: "obj->outputSchemeEntry(x0_)"
extern "C"
    int CasADi__IOInterface_CasADi__Function___outputSchemeEntry(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0);
int CasADi__IOInterface_CasADi__Function___outputSchemeEntry(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->outputSchemeEntry(x0_) );
}


// ================== Normal method: "schemeEntry" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::schemeEntry"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___schemeEntry"
// protoArgs: "(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(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0, std::string* x1, int x2)"
// call: "obj->schemeEntry(x0_, x1_, x2_)"
extern "C"
    int CasADi__IOInterface_CasADi__Function___schemeEntry(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0, std::string* x1, int x2);
int CasADi__IOInterface_CasADi__Function___schemeEntry(CasADi::IOInterface< CasADi::Function >* obj, CasADi::IOScheme* x0, std::string* x1, int x2){
    CasADi::IOScheme const & x0_ = Marshaling<CasADi::IOScheme const &,CasADi::IOScheme*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< int, int >::wrapReturn( obj->schemeEntry(x0_, x1_, x2_) );
}


// ================== Normal method: "getInput" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getInput"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getInput"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// call: "obj->getInput(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput(CasADi::IOInterface< CasADi::Function >* obj, int x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput(CasADi::IOInterface< CasADi::Function >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getInput(x0_) );
}


// ================== Normal method: "getInput'" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getInput'"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getInput_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput_TIC(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->getInput()"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput_TIC(CasADi::IOInterface< CasADi::Function >* obj);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput_TIC(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getInput() );
}


// ================== Normal method: "getInput''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getInput''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// call: "obj->getInput(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getInput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getInput(x0_) );
}


// ================== Normal method: "getOutput" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getOutput"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getOutput"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput(CasADi::IOInterface< CasADi::Function >* obj, int x0)"
// call: "obj->getOutput(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput(CasADi::IOInterface< CasADi::Function >* obj, int x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput(CasADi::IOInterface< CasADi::Function >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getOutput(x0_) );
}


// ================== Normal method: "getOutput'" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getOutput'"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getOutput_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj)"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput_TIC(CasADi::IOInterface< CasADi::Function >* obj)"
// call: "obj->getOutput()"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput_TIC(CasADi::IOInterface< CasADi::Function >* obj);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput_TIC(CasADi::IOInterface< CasADi::Function >* obj){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getOutput() );
}


// ================== Normal method: "getOutput''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::getOutput''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0)"
// call: "obj->getOutput(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__Function___getOutput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->getOutput(x0_) );
}


// ================== Normal method: "setInput" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1);
void CasADi__IOInterface_CasADi__Function___setInput(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setInput(x0_, x1_);
}


// ================== Normal method: "setInput'" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput'"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0)"
// call: "obj->setInput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0);
void CasADi__IOInterface_CasADi__Function___setInput_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->setInput(x0_);
}


// ================== Normal method: "setOutput" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1);
void CasADi__IOInterface_CasADi__Function___setOutput(CasADi::IOInterface< CasADi::Function >* obj, double x0, int x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setOutput'" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput'"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, double x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0)"
// call: "obj->setOutput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    obj->setOutput(x0_);
}


// ================== Normal method: "setInput''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setInput(x0_, x1_);
}


// ================== Normal method: "setOutput''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, double x0, std::string* x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setInput'''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput'''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, int x1);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, int x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setInput(x0_, x1_);
}


// ================== Normal method: "setInput''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0)"
// call: "obj->setInput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setInput(x0_);
}


// ================== Normal method: "setOutput'''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput'''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, int x1);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, int x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setOutput''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0)"
// call: "obj->setOutput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    obj->setOutput(x0_);
}


// ================== Normal method: "setInput'''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput'''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, std::string* x1);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, std::string* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setInput(x0_, x1_);
}


// ================== Normal method: "setOutput'''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput'''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, std::string* x1);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, std::vector< double >* x0, std::string* x1){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setInput''''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setInput(x0_, x1_);
}


// ================== Normal method: "setInput'''''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput'''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->setInput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    obj->setInput(x0_);
}


// ================== Normal method: "setOutput''''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setOutput'''''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput'''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0)"
// call: "obj->setOutput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    obj->setOutput(x0_);
}


// ================== Normal method: "setInput''''''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setInput''''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1);
void CasADi__IOInterface_CasADi__Function___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setInput(x0_, x1_);
}


// ================== Normal method: "setOutput''''''''" ===============
// class: "CasADi::IOInterface< CasADi::Function >"
// cppName: "CasADi::IOInterface< CasADi::Function >::setOutput''''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1);
void CasADi__IOInterface_CasADi__Function___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::Function >* obj, CasADi::Matrix< double >* x0, std::string* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setOutput(x0_, x1_);
}


// ================== delete CasadiClass SDQPStructure===============
// classType: CasadiClass SDQPStructure
extern "C"
    void delete_CasADi__SDQPStructIOSchemeVector_CasADi__Sparsity_(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* obj);
void delete_CasADi__SDQPStructIOSchemeVector_CasADi__Sparsity_(CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* obj){
    delete obj;
}

// ================== Constructor method: "SDQPStructure" ===============
// class: "CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >"
// cppName: "CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >"
// cWrapperName: "CasADi__SDQPStructIOSchemeVector_CasADi__Sparsity___SDQPStructure"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SDQPStructure
// cWrapperRetType: "CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >*"
// proto: "CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SDQPStructIOSchemeVector_CasADi__Sparsity___SDQPStructure(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >(x0_)"
extern "C"
    CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SDQPStructIOSchemeVector_CasADi__Sparsity___SDQPStructure(std::vector< CasADi::Sparsity* >* x0);
CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SDQPStructIOSchemeVector_CasADi__Sparsity___SDQPStructure(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >*, CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity > >::wrapReturn( CasADi::SDQPStructIOSchemeVector< CasADi::Sparsity >(x0_) );
}


// ================== delete CasadiClass SDPStructure===============
// classType: CasadiClass SDPStructure
extern "C"
    void delete_CasADi__SDPStructIOSchemeVector_CasADi__Sparsity_(CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >* obj);
void delete_CasADi__SDPStructIOSchemeVector_CasADi__Sparsity_(CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >* obj){
    delete obj;
}

// ================== Constructor method: "SDPStructure" ===============
// class: "CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >"
// cppName: "CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >"
// cWrapperName: "CasADi__SDPStructIOSchemeVector_CasADi__Sparsity___SDPStructure"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SDPStructure
// cWrapperRetType: "CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >*"
// proto: "CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SDPStructIOSchemeVector_CasADi__Sparsity___SDPStructure(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >(x0_)"
extern "C"
    CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SDPStructIOSchemeVector_CasADi__Sparsity___SDPStructure(std::vector< CasADi::Sparsity* >* x0);
CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SDPStructIOSchemeVector_CasADi__Sparsity___SDPStructure(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >*, CasADi::SDPStructIOSchemeVector< CasADi::Sparsity > >::wrapReturn( CasADi::SDPStructIOSchemeVector< CasADi::Sparsity >(x0_) );
}


// ================== delete CasadiClass GenDMatrix===============
// classType: CasadiClass GenDMatrix
extern "C"
    void delete_CasADi__GenericMatrix_CasADi__Matrix_double__(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
void delete_CasADi__GenericMatrix_CasADi__Matrix_double__(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){
    delete obj;
}

// ================== Normal method: "size" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::size"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____size"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____size(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____size(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____size(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size() );
}


// ================== Normal method: "sizeL" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sizeL"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sizeL"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____sizeL(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->sizeL()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____sizeL(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____sizeL(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeL() );
}


// ================== Normal method: "sizeU" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sizeU"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sizeU"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____sizeU(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->sizeU()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____sizeU(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____sizeU(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeU() );
}


// ================== Normal method: "sizeD" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sizeD"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sizeD"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____sizeD(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->sizeD()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____sizeD(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____sizeD(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->sizeD() );
}


// ================== Normal method: "numel" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::numel"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____numel"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____numel(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____numel(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____numel(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->numel() );
}


// ================== Normal method: "size1" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::size1"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____size1"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____size1(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____size1(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____size1(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size1() );
}


// ================== Normal method: "size2" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::size2"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____size2"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____size2(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____size2(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____size2(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size2() );
}


// ================== Normal method: "size'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::size'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::SparsityType x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::SparsityType x0)"
// call: "obj->size(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::SparsityType x0);
int CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::SparsityType x0){
    CasADi::SparsityType x0_ = Marshaling<CasADi::SparsityType,CasADi::SparsityType>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->size(x0_) );
}


// ================== Normal method: "dimString" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::dimString"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____dimString"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericMatrix_CasADi__Matrix_double____dimString(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->dimString()"
extern "C"
    std::string* CasADi__GenericMatrix_CasADi__Matrix_double____dimString(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
std::string* CasADi__GenericMatrix_CasADi__Matrix_double____dimString(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->dimString() );
}


// ================== Normal method: "isEmpty" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isEmpty"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0)"
// call: "obj->isEmpty(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0);
int CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty(x0_) );
}


// ================== Normal method: "isEmpty'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isEmpty'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isEmpty()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isEmpty() );
}


// ================== Normal method: "isDense" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isDense"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isDense"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isDense(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isDense()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isDense(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isDense(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isDense() );
}


// ================== Normal method: "isScalar" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isScalar"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isScalar"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isScalar(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0)"
// call: "obj->isScalar(x0_)"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isScalar(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0);
int CasADi__GenericMatrix_CasADi__Matrix_double____isScalar(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar(x0_) );
}


// ================== Normal method: "isScalar'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isScalar'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isScalar()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isScalar() );
}


// ================== Normal method: "isSquare" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isSquare"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isSquare"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isSquare(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isSquare()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isSquare(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isSquare(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isSquare() );
}


// ================== Normal method: "isVector" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isVector"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isVector"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isVector(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isVector()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isVector(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isVector(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isVector() );
}


// ================== Normal method: "isTriu" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isTriu"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isTriu"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isTriu(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isTriu()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isTriu(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isTriu(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTriu() );
}


// ================== Normal method: "isTril" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::isTril"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____isTril"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__GenericMatrix_CasADi__Matrix_double____isTril(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->isTril()"
extern "C"
    int CasADi__GenericMatrix_CasADi__Matrix_double____isTril(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
int CasADi__GenericMatrix_CasADi__Matrix_double____isTril(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->isTril() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparsityRef"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj);
CasADi::Sparsity* CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->sparsityRef() );
}


// ================== Static method: "sym" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym"
// protoArgs: "(std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym(std::string* x0, int x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym(std::string* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym(std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC"
// protoArgs: "(std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC(std::string* x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC(std::string* x0, int x1);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC(std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_) );
}


// ================== Static method: "sym''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC(std::string* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC(std::string* x0);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_) );
}


// ================== Static method: "sym'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_) );
}


// ================== Static method: "sym''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass DMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2);
std::vector< CasADi::Matrix< double >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_) );
}


// ================== Static method: "sym'''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym'''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (CasadiClass DMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);
std::vector< CasADi::Matrix< double >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: StdVec (StdVec (CasadiClass DMatrix))
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< double >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3);
std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::Sparsity* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< double >* >* >*, std::vector< std::vector< CasADi::Matrix< double > > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_, x3_) );
}


// ================== Static method: "sym'''''''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym'''''''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: StdVec (StdVec (CasadiClass DMatrix))
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< double >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);
std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< double >* >* >*, std::vector< std::vector< CasADi::Matrix< double > > > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sym(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "sparse" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sparse"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse(int x0, int x1);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC(int x0);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse(x0_) );
}


// ================== Static method: "sparse''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse()"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC();
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::sparse() );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____zeros"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros(int x0, int x1);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros(x0_, x1_) );
}


// ================== Static method: "zeros'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC(int x0);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros(x0_) );
}


// ================== Static method: "zeros''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros()"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC();
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros() );
}


// ================== Static method: "zeros'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____ones"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones(int x0, int x1)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones(int x0, int x1);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::ones(x0_, x1_) );
}


// ================== Static method: "ones'" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones'"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC(int x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC(int x0);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::ones(x0_) );
}


// ================== Static method: "ones''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC()"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones()"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC();
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC(){

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::ones() );
}


// ================== Static method: "ones'''" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones'''"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::GenericMatrix< CasADi::Matrix< double > >::ones(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::GenericMatrix< CasADi::Matrix< double > >::ones(x0_) );
}


// ================== Normal method: "mul_smart" ===============
// class: "CasADi::GenericMatrix< CasADi::Matrix< double > >"
// cppName: "CasADi::GenericMatrix< CasADi::Matrix< double > >::mul_smart"
// cWrapperName: "CasADi__GenericMatrix_CasADi__Matrix_double____mul_smart"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass DMatrix
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// call: "obj->mul_smart(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__GenericMatrix_CasADi__Matrix_double____mul_smart(CasADi::GenericMatrix< CasADi::Matrix< double > >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( obj->mul_smart(x0_, x1_) );
}


// ================== delete CasadiClass ExpIMatrix===============
// classType: CasadiClass ExpIMatrix
extern "C"
    void delete_CasADi__GenericExpression_CasADi__Matrix_int__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj);
void delete_CasADi__GenericExpression_CasADi__Matrix_int__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj){
    delete obj;
}

// ================== Normal method: "__mldivide__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__mldivide__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______mldivide__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______mldivide__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__mldivide__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______mldivide__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______mldivide__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__mldivide__(x0_) );
}


// ================== Normal method: "__gt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__gt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______gt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______gt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__gt__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______gt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______gt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__gt__(x0_) );
}


// ================== Normal method: "__ge__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__ge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______ge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______ge__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__ge__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______ge__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______ge__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__ge__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__truediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______truediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______truediv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______truediv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______truediv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__truediv__(x0_) );
}


// ================== Normal method: "__radd__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__radd__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______radd__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______radd__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__radd__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______radd__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______radd__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__radd__(x0_) );
}


// ================== Normal method: "__rsub__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rsub__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rsub__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rsub__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rsub__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rsub__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rsub__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rsub__(x0_) );
}


// ================== Normal method: "__rmul__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rmul__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rmul__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rmul__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rmul__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rmul__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rmul__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rmul__(x0_) );
}


// ================== Normal method: "__rdiv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rdiv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rdiv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rdiv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rdiv__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rdiv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rdiv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rdiv__(x0_) );
}


// ================== Normal method: "__rlt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rlt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rlt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rlt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rlt__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rlt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rlt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rlt__(x0_) );
}


// ================== Normal method: "__rle__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rle__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rle__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rle__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rle__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rle__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rle__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rle__(x0_) );
}


// ================== Normal method: "__rgt__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rgt__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rgt__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rgt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rgt__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rgt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rgt__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rgt__(x0_) );
}


// ================== Normal method: "__rge__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rge__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rge__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rge__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rge__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rge__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rge__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rge__(x0_) );
}


// ================== Normal method: "__req__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__req__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______req__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______req__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__req__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______req__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______req__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__req__(x0_) );
}


// ================== Normal method: "__rne__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rne__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rne__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rne__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rne__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rne__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rne__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rne__(x0_) );
}


// ================== Normal method: "__rtruediv__" ===============
// class: "CasADi::GenericExpression< CasADi::Matrix< int > >"
// cppName: "CasADi::GenericExpression< CasADi::Matrix< int > >::__rtruediv__"
// cWrapperName: "CasADi__GenericExpression_CasADi__Matrix_int______rtruediv__"
// protoArgs: "(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IMatrix
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0)"
// call: "obj->__rtruediv__(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__GenericExpression_CasADi__Matrix_int______rtruediv__(CasADi::GenericExpression< CasADi::Matrix< int > >* obj, CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( obj->__rtruediv__(x0_) );
}


// ================== delete CasadiClass CustomFunction===============
// classType: CasadiClass CustomFunction
extern "C"
    void delete_CasADi__CustomFunction(CasADi::CustomFunction* obj);
void delete_CasADi__CustomFunction(CasADi::CustomFunction* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::CustomFunction"
// cppName: "CasADi::CustomFunction::checkNode"
// cWrapperName: "CasADi__CustomFunction__checkNode"
// protoArgs: "(CasADi::CustomFunction* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj);
int CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "CustomFunction" ===============
// class: "CasADi::CustomFunction"
// cppName: "CasADi::CustomFunction"
// cWrapperName: "CasADi__CustomFunction__CustomFunction"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass CustomFunction
// cWrapperRetType: "CasADi::CustomFunction*"
// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction()"
// call: "CasADi::CustomFunction()"
extern "C"
    CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction();
CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction(){

    return WrapReturn< CasADi::CustomFunction*, CasADi::CustomFunction >::wrapReturn( CasADi::CustomFunction() );
}


// ================== Constructor method: "CustomFunction'" ===============
// class: "CasADi::CustomFunction"
// cppName: "CasADi::CustomFunction"
// cWrapperName: "CasADi__CustomFunction__CustomFunction_TIC"
// protoArgs: "(CasADi::CustomEvaluate* x0, std::vector< CasADi::Sparsity* >* x1, std::vector< CasADi::Sparsity* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass CustomFunction
// cWrapperRetType: "CasADi::CustomFunction*"
// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector< CasADi::Sparsity* >* x1, std::vector< CasADi::Sparsity* >* x2)"
// call: "CasADi::CustomFunction(x0_, x1_, x2_)"
extern "C"
    CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector< CasADi::Sparsity* >* x1, std::vector< CasADi::Sparsity* >* x2);
CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector< CasADi::Sparsity* >* x1, std::vector< CasADi::Sparsity* >* x2){
    CasADi::CustomEvaluate const & x0_ = Marshaling<CasADi::CustomEvaluate const &,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);

    return WrapReturn< CasADi::CustomFunction*, CasADi::CustomFunction >::wrapReturn( CasADi::CustomFunction(x0_, x1_, x2_) );
}


// ================== Constructor method: "CustomFunction'''''" ===============
// class: "CasADi::CustomFunction"
// cppName: "CasADi::CustomFunction"
// cWrapperName: "CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::CustomEvaluate* x0)"
// args: "(x0_)"
// rettype: CasadiClass CustomFunction
// cWrapperRetType: "CasADi::CustomFunction*"
// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC(CasADi::CustomEvaluate* x0)"
// call: "CasADi::CustomFunction(x0_)"
extern "C"
    CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC(CasADi::CustomEvaluate* x0);
CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC(CasADi::CustomEvaluate* x0){
    CasADi::CustomEvaluate const & x0_ = Marshaling<CasADi::CustomEvaluate const &,CasADi::CustomEvaluate*>::marshal(x0);

    return WrapReturn< CasADi::CustomFunction*, CasADi::CustomFunction >::wrapReturn( CasADi::CustomFunction(x0_) );
}


// ================== delete CasadiClass LPSolver===============
// classType: CasadiClass LPSolver
extern "C"
    void delete_CasADi__LPSolver(CasADi::LPSolver* obj);
void delete_CasADi__LPSolver(CasADi::LPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::LPSolver"
// cppName: "CasADi::LPSolver::checkNode"
// cWrapperName: "CasADi__LPSolver__checkNode"
// protoArgs: "(CasADi::LPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__LPSolver__checkNode(CasADi::LPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__LPSolver__checkNode(CasADi::LPSolver* obj);
int CasADi__LPSolver__checkNode(CasADi::LPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "LPSolver" ===============
// class: "CasADi::LPSolver"
// cppName: "CasADi::LPSolver"
// cWrapperName: "CasADi__LPSolver__LPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass LPSolver
// cWrapperRetType: "CasADi::LPSolver*"
// proto: "CasADi::LPSolver* CasADi__LPSolver__LPSolver()"
// call: "CasADi::LPSolver()"
extern "C"
    CasADi::LPSolver* CasADi__LPSolver__LPSolver();
CasADi::LPSolver* CasADi__LPSolver__LPSolver(){

    return WrapReturn< CasADi::LPSolver*, CasADi::LPSolver >::wrapReturn( CasADi::LPSolver() );
}


// ================== delete CasadiClass OCPSolver===============
// classType: CasadiClass OCPSolver
extern "C"
    void delete_CasADi__OCPSolver(CasADi::OCPSolver* obj);
void delete_CasADi__OCPSolver(CasADi::OCPSolver* obj){
    delete obj;
}

// ================== Normal method: "getFfcn" ===============
// class: "CasADi::OCPSolver"
// cppName: "CasADi::OCPSolver::getFfcn"
// cWrapperName: "CasADi__OCPSolver__getFfcn"
// protoArgs: "(CasADi::OCPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__OCPSolver__getFfcn(CasADi::OCPSolver* obj)"
// call: "obj->getFfcn()"
extern "C"
    CasADi::Function* CasADi__OCPSolver__getFfcn(CasADi::OCPSolver* obj);
CasADi::Function* CasADi__OCPSolver__getFfcn(CasADi::OCPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getFfcn() );
}


// ================== Normal method: "getMfcn" ===============
// class: "CasADi::OCPSolver"
// cppName: "CasADi::OCPSolver::getMfcn"
// cWrapperName: "CasADi__OCPSolver__getMfcn"
// protoArgs: "(CasADi::OCPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__OCPSolver__getMfcn(CasADi::OCPSolver* obj)"
// call: "obj->getMfcn()"
extern "C"
    CasADi::Function* CasADi__OCPSolver__getMfcn(CasADi::OCPSolver* obj);
CasADi::Function* CasADi__OCPSolver__getMfcn(CasADi::OCPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getMfcn() );
}


// ================== Normal method: "getCfcn" ===============
// class: "CasADi::OCPSolver"
// cppName: "CasADi::OCPSolver::getCfcn"
// cWrapperName: "CasADi__OCPSolver__getCfcn"
// protoArgs: "(CasADi::OCPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__OCPSolver__getCfcn(CasADi::OCPSolver* obj)"
// call: "obj->getCfcn()"
extern "C"
    CasADi::Function* CasADi__OCPSolver__getCfcn(CasADi::OCPSolver* obj);
CasADi::Function* CasADi__OCPSolver__getCfcn(CasADi::OCPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getCfcn() );
}


// ================== Normal method: "getRfcn" ===============
// class: "CasADi::OCPSolver"
// cppName: "CasADi::OCPSolver::getRfcn"
// cWrapperName: "CasADi__OCPSolver__getRfcn"
// protoArgs: "(CasADi::OCPSolver* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__OCPSolver__getRfcn(CasADi::OCPSolver* obj)"
// call: "obj->getRfcn()"
extern "C"
    CasADi::Function* CasADi__OCPSolver__getRfcn(CasADi::OCPSolver* obj);
CasADi::Function* CasADi__OCPSolver__getRfcn(CasADi::OCPSolver* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getRfcn() );
}


// ================== Constructor method: "OCPSolver" ===============
// class: "CasADi::OCPSolver"
// cppName: "CasADi::OCPSolver"
// cWrapperName: "CasADi__OCPSolver__OCPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass OCPSolver
// cWrapperRetType: "CasADi::OCPSolver*"
// proto: "CasADi::OCPSolver* CasADi__OCPSolver__OCPSolver()"
// call: "CasADi::OCPSolver()"
extern "C"
    CasADi::OCPSolver* CasADi__OCPSolver__OCPSolver();
CasADi::OCPSolver* CasADi__OCPSolver__OCPSolver(){

    return WrapReturn< CasADi::OCPSolver*, CasADi::OCPSolver >::wrapReturn( CasADi::OCPSolver() );
}


// ================== delete CasadiClass LinearSolver===============
// classType: CasadiClass LinearSolver
extern "C"
    void delete_CasADi__LinearSolver(CasADi::LinearSolver* obj);
void delete_CasADi__LinearSolver(CasADi::LinearSolver* obj){
    delete obj;
}

// ================== Normal method: "prepare" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::prepare"
// cWrapperName: "CasADi__LinearSolver__prepare"
// protoArgs: "(CasADi::LinearSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__LinearSolver__prepare(CasADi::LinearSolver* obj)"
// call: "obj->prepare()"
extern "C"
    void CasADi__LinearSolver__prepare(CasADi::LinearSolver* obj);
void CasADi__LinearSolver__prepare(CasADi::LinearSolver* obj){

    obj->prepare();
}


// ================== Normal method: "solve" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::solve"
// cWrapperName: "CasADi__LinearSolver__solve"
// protoArgs: "(CasADi::LinearSolver* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__LinearSolver__solve(CasADi::LinearSolver* obj, int x0)"
// call: "obj->solve(x0_)"
extern "C"
    void CasADi__LinearSolver__solve(CasADi::LinearSolver* obj, int x0);
void CasADi__LinearSolver__solve(CasADi::LinearSolver* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->solve(x0_);
}


// ================== Normal method: "solve'" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::solve'"
// cWrapperName: "CasADi__LinearSolver__solve_TIC"
// protoArgs: "(CasADi::LinearSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__LinearSolver__solve_TIC(CasADi::LinearSolver* obj)"
// call: "obj->solve()"
extern "C"
    void CasADi__LinearSolver__solve_TIC(CasADi::LinearSolver* obj);
void CasADi__LinearSolver__solve_TIC(CasADi::LinearSolver* obj){

    obj->solve();
}


// ================== Normal method: "solve''" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::solve''"
// cWrapperName: "CasADi__LinearSolver__solve_TIC_TIC"
// protoArgs: "(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__LinearSolver__solve_TIC_TIC(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1, int x2)"
// call: "obj->solve(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__LinearSolver__solve_TIC_TIC(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1, int x2);
CasADi::MX* CasADi__LinearSolver__solve_TIC_TIC(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->solve(x0_, x1_, x2_) );
}


// ================== Normal method: "solve'''" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::solve'''"
// cWrapperName: "CasADi__LinearSolver__solve_TIC_TIC_TIC"
// protoArgs: "(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass MX
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__LinearSolver__solve_TIC_TIC_TIC(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1)"
// call: "obj->solve(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__LinearSolver__solve_TIC_TIC_TIC(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__LinearSolver__solve_TIC_TIC_TIC(CasADi::LinearSolver* obj, CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( obj->solve(x0_, x1_) );
}


// ================== Normal method: "prepared" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::prepared"
// cWrapperName: "CasADi__LinearSolver__prepared"
// protoArgs: "(CasADi::LinearSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__LinearSolver__prepared(CasADi::LinearSolver* obj)"
// call: "obj->prepared()"
extern "C"
    int CasADi__LinearSolver__prepared(CasADi::LinearSolver* obj);
int CasADi__LinearSolver__prepared(CasADi::LinearSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->prepared() );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver::checkNode"
// cWrapperName: "CasADi__LinearSolver__checkNode"
// protoArgs: "(CasADi::LinearSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__LinearSolver__checkNode(CasADi::LinearSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__LinearSolver__checkNode(CasADi::LinearSolver* obj);
int CasADi__LinearSolver__checkNode(CasADi::LinearSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "LinearSolver" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver"
// cWrapperName: "CasADi__LinearSolver__LinearSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver()"
// call: "CasADi::LinearSolver()"
extern "C"
    CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver();
CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver(){

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( CasADi::LinearSolver() );
}


// ================== Constructor method: "LinearSolver'" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver"
// cWrapperName: "CasADi__LinearSolver__LinearSolver_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::LinearSolver(x0_, x1_)"
extern "C"
    CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver_TIC(CasADi::Sparsity* x0, int x1);
CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( CasADi::LinearSolver(x0_, x1_) );
}


// ================== Constructor method: "LinearSolver''" ===============
// class: "CasADi::LinearSolver"
// cppName: "CasADi::LinearSolver"
// cWrapperName: "CasADi__LinearSolver__LinearSolver_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// args: "(x0_)"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::LinearSolver(x0_)"
extern "C"
    CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver_TIC_TIC(CasADi::Sparsity* x0);
CasADi::LinearSolver* CasADi__LinearSolver__LinearSolver_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( CasADi::LinearSolver(x0_) );
}


// ================== delete CasadiClass SymbolicOCP===============
// classType: CasadiClass SymbolicOCP
extern "C"
    void delete_CasADi__SymbolicOCP(CasADi::SymbolicOCP* obj);
void delete_CasADi__SymbolicOCP(CasADi::SymbolicOCP* obj){
    delete obj;
}

// ================== Normal method: "parseFMI" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::parseFMI"
// cWrapperName: "CasADi__SymbolicOCP__parseFMI"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__parseFMI(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->parseFMI(x0_)"
extern "C"
    void CasADi__SymbolicOCP__parseFMI(CasADi::SymbolicOCP* obj, std::string* x0);
void CasADi__SymbolicOCP__parseFMI(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->parseFMI(x0_);
}


// ================== Normal method: "addVariable" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::addVariable"
// cWrapperName: "CasADi__SymbolicOCP__addVariable"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Variable* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__addVariable(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Variable* x1)"
// call: "obj->addVariable(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__addVariable(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Variable* x1);
void CasADi__SymbolicOCP__addVariable(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Variable* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Variable const & x1_ = Marshaling<CasADi::Variable const &,CasADi::Variable*>::marshal(x1);

    obj->addVariable(x0_, x1_);
}


// ================== Normal method: "variable" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::variable"
// cWrapperName: "CasADi__SymbolicOCP__variable"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass Variable
// cWrapperRetType: "CasADi::Variable*"
// proto: "CasADi::Variable* CasADi__SymbolicOCP__variable(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->variable(x0_)"
extern "C"
    CasADi::Variable* CasADi__SymbolicOCP__variable(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Variable* CasADi__SymbolicOCP__variable(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Variable*, CasADi::Variable >::wrapReturn( obj->variable(x0_) );
}


// ================== Normal method: "separateAlgebraic" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::separateAlgebraic"
// cWrapperName: "CasADi__SymbolicOCP__separateAlgebraic"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__separateAlgebraic(CasADi::SymbolicOCP* obj)"
// call: "obj->separateAlgebraic()"
extern "C"
    void CasADi__SymbolicOCP__separateAlgebraic(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__separateAlgebraic(CasADi::SymbolicOCP* obj){

    obj->separateAlgebraic();
}


// ================== Normal method: "eliminateAlgebraic" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateAlgebraic"
// cWrapperName: "CasADi__SymbolicOCP__eliminateAlgebraic"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateAlgebraic(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateAlgebraic()"
extern "C"
    void CasADi__SymbolicOCP__eliminateAlgebraic(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateAlgebraic(CasADi::SymbolicOCP* obj){

    obj->eliminateAlgebraic();
}


// ================== Normal method: "makeSemiExplicit" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::makeSemiExplicit"
// cWrapperName: "CasADi__SymbolicOCP__makeSemiExplicit"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__makeSemiExplicit(CasADi::SymbolicOCP* obj)"
// call: "obj->makeSemiExplicit()"
extern "C"
    void CasADi__SymbolicOCP__makeSemiExplicit(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__makeSemiExplicit(CasADi::SymbolicOCP* obj){

    obj->makeSemiExplicit();
}


// ================== Normal method: "makeExplicit" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::makeExplicit"
// cWrapperName: "CasADi__SymbolicOCP__makeExplicit"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__makeExplicit(CasADi::SymbolicOCP* obj)"
// call: "obj->makeExplicit()"
extern "C"
    void CasADi__SymbolicOCP__makeExplicit(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__makeExplicit(CasADi::SymbolicOCP* obj){

    obj->makeExplicit();
}


// ================== Normal method: "eliminateIndependentParameters" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateIndependentParameters"
// cWrapperName: "CasADi__SymbolicOCP__eliminateIndependentParameters"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateIndependentParameters(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateIndependentParameters()"
extern "C"
    void CasADi__SymbolicOCP__eliminateIndependentParameters(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateIndependentParameters(CasADi::SymbolicOCP* obj){

    obj->eliminateIndependentParameters();
}


// ================== Normal method: "sortDependentParameters" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::sortDependentParameters"
// cWrapperName: "CasADi__SymbolicOCP__sortDependentParameters"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__sortDependentParameters(CasADi::SymbolicOCP* obj)"
// call: "obj->sortDependentParameters()"
extern "C"
    void CasADi__SymbolicOCP__sortDependentParameters(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__sortDependentParameters(CasADi::SymbolicOCP* obj){

    obj->sortDependentParameters();
}


// ================== Normal method: "eliminateDependentParameterInterdependencies" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateDependentParameterInterdependencies"
// cWrapperName: "CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateDependentParameterInterdependencies()"
extern "C"
    void CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies(CasADi::SymbolicOCP* obj){

    obj->eliminateDependentParameterInterdependencies();
}


// ================== Normal method: "eliminateDependentParameters" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateDependentParameters"
// cWrapperName: "CasADi__SymbolicOCP__eliminateDependentParameters"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateDependentParameters(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateDependentParameters()"
extern "C"
    void CasADi__SymbolicOCP__eliminateDependentParameters(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateDependentParameters(CasADi::SymbolicOCP* obj){

    obj->eliminateDependentParameters();
}


// ================== Normal method: "sortOutputs" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::sortOutputs"
// cWrapperName: "CasADi__SymbolicOCP__sortOutputs"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__sortOutputs(CasADi::SymbolicOCP* obj)"
// call: "obj->sortOutputs()"
extern "C"
    void CasADi__SymbolicOCP__sortOutputs(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__sortOutputs(CasADi::SymbolicOCP* obj){

    obj->sortOutputs();
}


// ================== Normal method: "eliminateOutputInterdependencies" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateOutputInterdependencies"
// cWrapperName: "CasADi__SymbolicOCP__eliminateOutputInterdependencies"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateOutputInterdependencies(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateOutputInterdependencies()"
extern "C"
    void CasADi__SymbolicOCP__eliminateOutputInterdependencies(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateOutputInterdependencies(CasADi::SymbolicOCP* obj){

    obj->eliminateOutputInterdependencies();
}


// ================== Normal method: "eliminateOutputs" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateOutputs"
// cWrapperName: "CasADi__SymbolicOCP__eliminateOutputs"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateOutputs(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateOutputs()"
extern "C"
    void CasADi__SymbolicOCP__eliminateOutputs(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateOutputs(CasADi::SymbolicOCP* obj){

    obj->eliminateOutputs();
}


// ================== Normal method: "eliminateLagrangeTerms" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateLagrangeTerms"
// cWrapperName: "CasADi__SymbolicOCP__eliminateLagrangeTerms"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateLagrangeTerms(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateLagrangeTerms()"
extern "C"
    void CasADi__SymbolicOCP__eliminateLagrangeTerms(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateLagrangeTerms(CasADi::SymbolicOCP* obj){

    obj->eliminateLagrangeTerms();
}


// ================== Normal method: "eliminateQuadratureStates" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::eliminateQuadratureStates"
// cWrapperName: "CasADi__SymbolicOCP__eliminateQuadratureStates"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__eliminateQuadratureStates(CasADi::SymbolicOCP* obj)"
// call: "obj->eliminateQuadratureStates()"
extern "C"
    void CasADi__SymbolicOCP__eliminateQuadratureStates(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__eliminateQuadratureStates(CasADi::SymbolicOCP* obj){

    obj->eliminateQuadratureStates();
}


// ================== Normal method: "sortDAE" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::sortDAE"
// cWrapperName: "CasADi__SymbolicOCP__sortDAE"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__sortDAE(CasADi::SymbolicOCP* obj)"
// call: "obj->sortDAE()"
extern "C"
    void CasADi__SymbolicOCP__sortDAE(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__sortDAE(CasADi::SymbolicOCP* obj){

    obj->sortDAE();
}


// ================== Normal method: "sortALG" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::sortALG"
// cWrapperName: "CasADi__SymbolicOCP__sortALG"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__sortALG(CasADi::SymbolicOCP* obj)"
// call: "obj->sortALG()"
extern "C"
    void CasADi__SymbolicOCP__sortALG(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__sortALG(CasADi::SymbolicOCP* obj){

    obj->sortALG();
}


// ================== Normal method: "generateMuscodDatFile" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::generateMuscodDatFile"
// cWrapperName: "CasADi__SymbolicOCP__generateMuscodDatFile"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__generateMuscodDatFile(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->generateMuscodDatFile(x0_)"
extern "C"
    void CasADi__SymbolicOCP__generateMuscodDatFile(CasADi::SymbolicOCP* obj, std::string* x0);
void CasADi__SymbolicOCP__generateMuscodDatFile(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->generateMuscodDatFile(x0_);
}


// ================== Normal method: "scaleVariables" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::scaleVariables"
// cWrapperName: "CasADi__SymbolicOCP__scaleVariables"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__scaleVariables(CasADi::SymbolicOCP* obj)"
// call: "obj->scaleVariables()"
extern "C"
    void CasADi__SymbolicOCP__scaleVariables(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__scaleVariables(CasADi::SymbolicOCP* obj){

    obj->scaleVariables();
}


// ================== Normal method: "scaleEquations" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::scaleEquations"
// cWrapperName: "CasADi__SymbolicOCP__scaleEquations"
// protoArgs: "(CasADi::SymbolicOCP* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__scaleEquations(CasADi::SymbolicOCP* obj)"
// call: "obj->scaleEquations()"
extern "C"
    void CasADi__SymbolicOCP__scaleEquations(CasADi::SymbolicOCP* obj);
void CasADi__SymbolicOCP__scaleEquations(CasADi::SymbolicOCP* obj){

    obj->scaleEquations();
}


// ================== Normal method: "operator ()" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::operator ()"
// cWrapperName: "CasADi__SymbolicOCP__operator_call"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__operator_call(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->operator ()(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__operator_call(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__operator_call(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->operator ()(x0_) );
}


// ================== Normal method: "der" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::der"
// cWrapperName: "CasADi__SymbolicOCP__der"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__der(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->der(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__der(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__der(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->der(x0_) );
}


// ================== Normal method: "der'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::der'"
// cWrapperName: "CasADi__SymbolicOCP__der_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__der_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->der(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__der_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__der_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->der(x0_) );
}


// ================== Normal method: "beq" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::beq"
// cWrapperName: "CasADi__SymbolicOCP__beq"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__beq(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->beq(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__beq(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__beq(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->beq(x0_) );
}


// ================== Normal method: "beq'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::beq'"
// cWrapperName: "CasADi__SymbolicOCP__beq_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__beq_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->beq(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__beq_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__beq_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->beq(x0_) );
}


// ================== Normal method: "setBeq" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setBeq"
// cWrapperName: "CasADi__SymbolicOCP__setBeq"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setBeq(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setBeq(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setBeq(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setBeq(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setBeq(x0_, x1_);
}


// ================== Normal method: "setBeq'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setBeq'"
// cWrapperName: "CasADi__SymbolicOCP__setBeq_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setBeq_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setBeq(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setBeq_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setBeq_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setBeq(x0_, x1_);
}


// ================== Normal method: "ode" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::ode"
// cWrapperName: "CasADi__SymbolicOCP__ode"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__ode(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->ode(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__ode(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__ode(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->ode(x0_) );
}


// ================== Normal method: "ode'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::ode'"
// cWrapperName: "CasADi__SymbolicOCP__ode_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__ode_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->ode(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__ode_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__ode_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->ode(x0_) );
}


// ================== Normal method: "setOde" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setOde"
// cWrapperName: "CasADi__SymbolicOCP__setOde"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setOde(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setOde(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setOde(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setOde(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setOde(x0_, x1_);
}


// ================== Normal method: "setOde'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setOde'"
// cWrapperName: "CasADi__SymbolicOCP__setOde_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setOde_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setOde(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setOde_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setOde_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setOde(x0_, x1_);
}


// ================== Normal method: "nominal" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::nominal"
// cWrapperName: "CasADi__SymbolicOCP__nominal"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SymbolicOCP__nominal(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->nominal(x0_)"
extern "C"
    double CasADi__SymbolicOCP__nominal(CasADi::SymbolicOCP* obj, std::string* x0);
double CasADi__SymbolicOCP__nominal(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( obj->nominal(x0_) );
}


// ================== Normal method: "nominal'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::nominal'"
// cWrapperName: "CasADi__SymbolicOCP__nominal_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__SymbolicOCP__nominal_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->nominal(x0_)"
extern "C"
    std::vector< double >* CasADi__SymbolicOCP__nominal_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< double >* CasADi__SymbolicOCP__nominal_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->nominal(x0_) );
}


// ================== Normal method: "setNominal" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setNominal"
// cWrapperName: "CasADi__SymbolicOCP__setNominal"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setNominal(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// call: "obj->setNominal(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setNominal(CasADi::SymbolicOCP* obj, std::string* x0, double x1);
void CasADi__SymbolicOCP__setNominal(CasADi::SymbolicOCP* obj, std::string* x0, double x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    obj->setNominal(x0_, x1_);
}


// ================== Normal method: "setNominal'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setNominal'"
// cWrapperName: "CasADi__SymbolicOCP__setNominal_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setNominal_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1)"
// call: "obj->setNominal(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setNominal_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1);
void CasADi__SymbolicOCP__setNominal_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->setNominal(x0_, x1_);
}


// ================== Normal method: "min" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::min"
// cWrapperName: "CasADi__SymbolicOCP__min"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__min(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->min(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__min(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__min(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->min(x0_) );
}


// ================== Normal method: "min'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::min'"
// cWrapperName: "CasADi__SymbolicOCP__min_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__min_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->min(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__min_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__min_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->min(x0_) );
}


// ================== Normal method: "setMin" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setMin"
// cWrapperName: "CasADi__SymbolicOCP__setMin"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setMin(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setMin(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setMin(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setMin(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setMin(x0_, x1_);
}


// ================== Normal method: "setMin'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setMin'"
// cWrapperName: "CasADi__SymbolicOCP__setMin_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setMin_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setMin(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setMin_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setMin_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setMin(x0_, x1_);
}


// ================== Normal method: "max" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::max"
// cWrapperName: "CasADi__SymbolicOCP__max"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__max(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->max(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__max(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__max(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->max(x0_) );
}


// ================== Normal method: "max'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::max'"
// cWrapperName: "CasADi__SymbolicOCP__max_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__max_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->max(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__max_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__max_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->max(x0_) );
}


// ================== Normal method: "setMax" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setMax"
// cWrapperName: "CasADi__SymbolicOCP__setMax"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setMax(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setMax(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setMax(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setMax(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setMax(x0_, x1_);
}


// ================== Normal method: "setMax'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setMax'"
// cWrapperName: "CasADi__SymbolicOCP__setMax_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setMax_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setMax(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setMax_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setMax_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setMax(x0_, x1_);
}


// ================== Normal method: "initialGuess" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::initialGuess"
// cWrapperName: "CasADi__SymbolicOCP__initialGuess"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__initialGuess(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->initialGuess(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__initialGuess(CasADi::SymbolicOCP* obj, std::string* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__initialGuess(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->initialGuess(x0_) );
}


// ================== Normal method: "initialGuess'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::initialGuess'"
// cWrapperName: "CasADi__SymbolicOCP__initialGuess_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__initialGuess_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->initialGuess(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__initialGuess_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__initialGuess_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->initialGuess(x0_) );
}


// ================== Normal method: "setInitialGuess" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setInitialGuess"
// cWrapperName: "CasADi__SymbolicOCP__setInitialGuess"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setInitialGuess(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setInitialGuess(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setInitialGuess(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setInitialGuess(CasADi::SymbolicOCP* obj, std::string* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setInitialGuess(x0_, x1_);
}


// ================== Normal method: "setInitialGuess'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setInitialGuess'"
// cWrapperName: "CasADi__SymbolicOCP__setInitialGuess_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setInitialGuess_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "obj->setInitialGuess(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setInitialGuess_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__SymbolicOCP__setInitialGuess_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    obj->setInitialGuess(x0_, x1_);
}


// ================== Normal method: "start" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::start"
// cWrapperName: "CasADi__SymbolicOCP__start"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SymbolicOCP__start(CasADi::SymbolicOCP* obj, std::string* x0, int x1)"
// call: "obj->start(x0_, x1_)"
extern "C"
    double CasADi__SymbolicOCP__start(CasADi::SymbolicOCP* obj, std::string* x0, int x1);
double CasADi__SymbolicOCP__start(CasADi::SymbolicOCP* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< double, double >::wrapReturn( obj->start(x0_, x1_) );
}


// ================== Normal method: "start'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::start'"
// cWrapperName: "CasADi__SymbolicOCP__start_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SymbolicOCP__start_TIC(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->start(x0_)"
extern "C"
    double CasADi__SymbolicOCP__start_TIC(CasADi::SymbolicOCP* obj, std::string* x0);
double CasADi__SymbolicOCP__start_TIC(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( obj->start(x0_) );
}


// ================== Normal method: "start''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::start''"
// cWrapperName: "CasADi__SymbolicOCP__start_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__SymbolicOCP__start_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "obj->start(x0_, x1_)"
extern "C"
    std::vector< double >* CasADi__SymbolicOCP__start_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1);
std::vector< double >* CasADi__SymbolicOCP__start_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->start(x0_, x1_) );
}


// ================== Normal method: "start'''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::start'''"
// cWrapperName: "CasADi__SymbolicOCP__start_TIC_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__SymbolicOCP__start_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->start(x0_)"
extern "C"
    std::vector< double >* CasADi__SymbolicOCP__start_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< double >* CasADi__SymbolicOCP__start_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->start(x0_) );
}


// ================== Normal method: "setStart" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setStart"
// cWrapperName: "CasADi__SymbolicOCP__setStart"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setStart(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// call: "obj->setStart(x0_, x1_, x2_)"
extern "C"
    void CasADi__SymbolicOCP__setStart(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2);
void CasADi__SymbolicOCP__setStart(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    obj->setStart(x0_, x1_, x2_);
}


// ================== Normal method: "setStart'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setStart'"
// cWrapperName: "CasADi__SymbolicOCP__setStart_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// call: "obj->setStart(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1);
void CasADi__SymbolicOCP__setStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    obj->setStart(x0_, x1_);
}


// ================== Normal method: "setStart''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setStart''"
// cWrapperName: "CasADi__SymbolicOCP__setStart_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2)"
// call: "obj->setStart(x0_, x1_, x2_)"
extern "C"
    void CasADi__SymbolicOCP__setStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2);
void CasADi__SymbolicOCP__setStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::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_);
}


// ================== Normal method: "setStart'''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setStart'''"
// cWrapperName: "CasADi__SymbolicOCP__setStart_TIC_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1)"
// call: "obj->setStart(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1);
void CasADi__SymbolicOCP__setStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->setStart(x0_, x1_);
}


// ================== Normal method: "derivativeStart" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::derivativeStart"
// cWrapperName: "CasADi__SymbolicOCP__derivativeStart"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SymbolicOCP__derivativeStart(CasADi::SymbolicOCP* obj, std::string* x0, int x1)"
// call: "obj->derivativeStart(x0_, x1_)"
extern "C"
    double CasADi__SymbolicOCP__derivativeStart(CasADi::SymbolicOCP* obj, std::string* x0, int x1);
double CasADi__SymbolicOCP__derivativeStart(CasADi::SymbolicOCP* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< double, double >::wrapReturn( obj->derivativeStart(x0_, x1_) );
}


// ================== Normal method: "derivativeStart'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::derivativeStart'"
// cWrapperName: "CasADi__SymbolicOCP__derivativeStart_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CDouble
// cWrapperRetType: "double"
// proto: "double CasADi__SymbolicOCP__derivativeStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->derivativeStart(x0_)"
extern "C"
    double CasADi__SymbolicOCP__derivativeStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0);
double CasADi__SymbolicOCP__derivativeStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( obj->derivativeStart(x0_) );
}


// ================== Normal method: "derivativeStart''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::derivativeStart''"
// cWrapperName: "CasADi__SymbolicOCP__derivativeStart_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__SymbolicOCP__derivativeStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "obj->derivativeStart(x0_, x1_)"
extern "C"
    std::vector< double >* CasADi__SymbolicOCP__derivativeStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1);
std::vector< double >* CasADi__SymbolicOCP__derivativeStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->derivativeStart(x0_, x1_) );
}


// ================== Normal method: "derivativeStart'''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::derivativeStart'''"
// cWrapperName: "CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: StdVec CDouble
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->derivativeStart(x0_)"
extern "C"
    std::vector< double >* CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< double >* CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( obj->derivativeStart(x0_) );
}


// ================== Normal method: "setDerivativeStart" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setDerivativeStart"
// cWrapperName: "CasADi__SymbolicOCP__setDerivativeStart"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setDerivativeStart(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// call: "obj->setDerivativeStart(x0_, x1_, x2_)"
extern "C"
    void CasADi__SymbolicOCP__setDerivativeStart(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2);
void CasADi__SymbolicOCP__setDerivativeStart(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    obj->setDerivativeStart(x0_, x1_, x2_);
}


// ================== Normal method: "setDerivativeStart'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setDerivativeStart'"
// cWrapperName: "CasADi__SymbolicOCP__setDerivativeStart_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setDerivativeStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// call: "obj->setDerivativeStart(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setDerivativeStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1);
void CasADi__SymbolicOCP__setDerivativeStart_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    obj->setDerivativeStart(x0_, x1_);
}


// ================== Normal method: "setDerivativeStart''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setDerivativeStart''"
// cWrapperName: "CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2)"
// call: "obj->setDerivativeStart(x0_, x1_, x2_)"
extern "C"
    void CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2);
void CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::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_);
}


// ================== Normal method: "setDerivativeStart'''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setDerivativeStart'''"
// cWrapperName: "CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1)"
// call: "obj->setDerivativeStart(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1);
void CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0, std::vector< double >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);

    obj->setDerivativeStart(x0_, x1_);
}


// ================== Normal method: "unit" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::unit"
// cWrapperName: "CasADi__SymbolicOCP__unit"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__SymbolicOCP__unit(CasADi::SymbolicOCP* obj, std::string* x0)"
// call: "obj->unit(x0_)"
extern "C"
    std::string* CasADi__SymbolicOCP__unit(CasADi::SymbolicOCP* obj, std::string* x0);
std::string* CasADi__SymbolicOCP__unit(CasADi::SymbolicOCP* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->unit(x0_) );
}


// ================== Normal method: "unit'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::unit'"
// cWrapperName: "CasADi__SymbolicOCP__unit_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__SymbolicOCP__unit_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "obj->unit(x0_)"
extern "C"
    std::string* CasADi__SymbolicOCP__unit_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0);
std::string* CasADi__SymbolicOCP__unit_TIC(CasADi::SymbolicOCP* obj, CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->unit(x0_) );
}


// ================== Normal method: "setUnit" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::setUnit"
// cWrapperName: "CasADi__SymbolicOCP__setUnit"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__SymbolicOCP__setUnit(CasADi::SymbolicOCP* obj, std::string* x0, std::string* x1)"
// call: "obj->setUnit(x0_, x1_)"
extern "C"
    void CasADi__SymbolicOCP__setUnit(CasADi::SymbolicOCP* obj, std::string* x0, std::string* x1);
void CasADi__SymbolicOCP__setUnit(CasADi::SymbolicOCP* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    obj->setUnit(x0_, x1_);
}


// ================== Normal method: "atTime" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::atTime"
// cWrapperName: "CasADi__SymbolicOCP__atTime"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// call: "obj->atTime(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->atTime(x0_, x1_, x2_) );
}


// ================== Normal method: "atTime'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::atTime'"
// cWrapperName: "CasADi__SymbolicOCP__atTime_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// call: "obj->atTime(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->atTime(x0_, x1_) );
}


// ================== Normal method: "atTime''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::atTime''"
// cWrapperName: "CasADi__SymbolicOCP__atTime_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2)"
// call: "obj->atTime(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->atTime(x0_, x1_, x2_) );
}


// ================== Normal method: "atTime'''" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP::atTime'''"
// cWrapperName: "CasADi__SymbolicOCP__atTime_TIC_TIC_TIC"
// protoArgs: "(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass SX
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1)"
// call: "obj->atTime(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__SymbolicOCP__atTime_TIC_TIC_TIC(CasADi::SymbolicOCP* obj, std::string* x0, double x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( obj->atTime(x0_, x1_) );
}


// ================== Constructor method: "SymbolicOCP" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP"
// cWrapperName: "CasADi__SymbolicOCP__SymbolicOCP"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass SymbolicOCP
// cWrapperRetType: "CasADi::SymbolicOCP*"
// proto: "CasADi::SymbolicOCP* CasADi__SymbolicOCP__SymbolicOCP(int x0)"
// call: "CasADi::SymbolicOCP(x0_)"
extern "C"
    CasADi::SymbolicOCP* CasADi__SymbolicOCP__SymbolicOCP(int x0);
CasADi::SymbolicOCP* CasADi__SymbolicOCP__SymbolicOCP(int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< CasADi::SymbolicOCP*, CasADi::SymbolicOCP >::wrapReturn( CasADi::SymbolicOCP(x0_) );
}


// ================== Constructor method: "SymbolicOCP'" ===============
// class: "CasADi::SymbolicOCP"
// cppName: "CasADi::SymbolicOCP"
// cWrapperName: "CasADi__SymbolicOCP__SymbolicOCP_TIC"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SymbolicOCP
// cWrapperRetType: "CasADi::SymbolicOCP*"
// proto: "CasADi::SymbolicOCP* CasADi__SymbolicOCP__SymbolicOCP_TIC()"
// call: "CasADi::SymbolicOCP()"
extern "C"
    CasADi::SymbolicOCP* CasADi__SymbolicOCP__SymbolicOCP_TIC();
CasADi::SymbolicOCP* CasADi__SymbolicOCP__SymbolicOCP_TIC(){

    return WrapReturn< CasADi::SymbolicOCP*, CasADi::SymbolicOCP >::wrapReturn( CasADi::SymbolicOCP() );
}


// ================== delete CasadiClass Function===============
// classType: CasadiClass Function
extern "C"
    void delete_CasADi__Function(CasADi::Function* obj);
void delete_CasADi__Function(CasADi::Function* obj){
    delete obj;
}

// ================== Normal method: "inputScheme" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::inputScheme"
// cWrapperName: "CasADi__Function__inputScheme"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__Function__inputScheme(CasADi::Function* obj)"
// call: "obj->inputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__Function__inputScheme(CasADi::Function* obj);
CasADi::IOScheme* CasADi__Function__inputScheme(CasADi::Function* obj){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( obj->inputScheme() );
}


// ================== Normal method: "outputScheme" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::outputScheme"
// cWrapperName: "CasADi__Function__outputScheme"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__Function__outputScheme(CasADi::Function* obj)"
// call: "obj->outputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__Function__outputScheme(CasADi::Function* obj);
CasADi::IOScheme* CasADi__Function__outputScheme(CasADi::Function* obj){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( obj->outputScheme() );
}


// ================== Normal method: "getNumInputNonzeros" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getNumInputNonzeros"
// cWrapperName: "CasADi__Function__getNumInputNonzeros"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Function__getNumInputNonzeros(CasADi::Function* obj)"
// call: "obj->getNumInputNonzeros()"
extern "C"
    int CasADi__Function__getNumInputNonzeros(CasADi::Function* obj);
int CasADi__Function__getNumInputNonzeros(CasADi::Function* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumInputNonzeros() );
}


// ================== Normal method: "getNumOutputNonzeros" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getNumOutputNonzeros"
// cWrapperName: "CasADi__Function__getNumOutputNonzeros"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Function__getNumOutputNonzeros(CasADi::Function* obj)"
// call: "obj->getNumOutputNonzeros()"
extern "C"
    int CasADi__Function__getNumOutputNonzeros(CasADi::Function* obj);
int CasADi__Function__getNumOutputNonzeros(CasADi::Function* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumOutputNonzeros() );
}


// ================== Normal method: "getNumInputElements" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getNumInputElements"
// cWrapperName: "CasADi__Function__getNumInputElements"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Function__getNumInputElements(CasADi::Function* obj)"
// call: "obj->getNumInputElements()"
extern "C"
    int CasADi__Function__getNumInputElements(CasADi::Function* obj);
int CasADi__Function__getNumInputElements(CasADi::Function* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumInputElements() );
}


// ================== Normal method: "getNumOutputElements" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getNumOutputElements"
// cWrapperName: "CasADi__Function__getNumOutputElements"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__Function__getNumOutputElements(CasADi::Function* obj)"
// call: "obj->getNumOutputElements()"
extern "C"
    int CasADi__Function__getNumOutputElements(CasADi::Function* obj);
int CasADi__Function__getNumOutputElements(CasADi::Function* obj){

    return WrapReturn< int, int >::wrapReturn( obj->getNumOutputElements() );
}


// ================== Normal method: "setInputScheme" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setInputScheme"
// cWrapperName: "CasADi__Function__setInputScheme"
// protoArgs: "(CasADi::Function* obj, CasADi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setInputScheme(CasADi::Function* obj, CasADi::IOScheme* x0)"
// call: "obj->setInputScheme(x0_)"
extern "C"
    void CasADi__Function__setInputScheme(CasADi::Function* obj, CasADi::IOScheme* x0);
void CasADi__Function__setInputScheme(CasADi::Function* obj, CasADi::IOScheme* x0){
    CasADi::IOScheme const & x0_ = Marshaling<CasADi::IOScheme const &,CasADi::IOScheme*>::marshal(x0);

    obj->setInputScheme(x0_);
}


// ================== Normal method: "setOutputScheme" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setOutputScheme"
// cWrapperName: "CasADi__Function__setOutputScheme"
// protoArgs: "(CasADi::Function* obj, CasADi::IOScheme* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setOutputScheme(CasADi::Function* obj, CasADi::IOScheme* x0)"
// call: "obj->setOutputScheme(x0_)"
extern "C"
    void CasADi__Function__setOutputScheme(CasADi::Function* obj, CasADi::IOScheme* x0);
void CasADi__Function__setOutputScheme(CasADi::Function* obj, CasADi::IOScheme* x0){
    CasADi::IOScheme const & x0_ = Marshaling<CasADi::IOScheme const &,CasADi::IOScheme*>::marshal(x0);

    obj->setOutputScheme(x0_);
}


// ================== Normal method: "getInputScheme" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getInputScheme"
// cWrapperName: "CasADi__Function__getInputScheme"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__Function__getInputScheme(CasADi::Function* obj)"
// call: "obj->getInputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__Function__getInputScheme(CasADi::Function* obj);
CasADi::IOScheme* CasADi__Function__getInputScheme(CasADi::Function* obj){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( obj->getInputScheme() );
}


// ================== Normal method: "getOutputScheme" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getOutputScheme"
// cWrapperName: "CasADi__Function__getOutputScheme"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__Function__getOutputScheme(CasADi::Function* obj)"
// call: "obj->getOutputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__Function__getOutputScheme(CasADi::Function* obj);
CasADi::IOScheme* CasADi__Function__getOutputScheme(CasADi::Function* obj){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( obj->getOutputScheme() );
}


// ================== Normal method: "evaluate" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::evaluate"
// cWrapperName: "CasADi__Function__evaluate"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__evaluate(CasADi::Function* obj)"
// call: "obj->evaluate()"
extern "C"
    void CasADi__Function__evaluate(CasADi::Function* obj);
void CasADi__Function__evaluate(CasADi::Function* obj){

    obj->evaluate();
}


// ================== Normal method: "solve" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::solve"
// cWrapperName: "CasADi__Function__solve"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__solve(CasADi::Function* obj)"
// call: "obj->solve()"
extern "C"
    void CasADi__Function__solve(CasADi::Function* obj);
void CasADi__Function__solve(CasADi::Function* obj){

    obj->solve();
}


// ================== Normal method: "jacobian" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian"
// cWrapperName: "CasADi__Function__jacobian"
// protoArgs: "(CasADi::Function* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian(CasADi::Function* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian(CasADi::Function* obj, int x0, int x1, int x2, int x3);
CasADi::Function* CasADi__Function__jacobian(CasADi::Function* obj, int x0, int x1, int x2, int x3){
    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);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacobian'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'"
// cWrapperName: "CasADi__Function__jacobian_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC(CasADi::Function* obj, int x0, int x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC(CasADi::Function* obj, int x0, int x1, int x2);
CasADi::Function* CasADi__Function__jacobian_TIC(CasADi::Function* obj, int x0, int x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_) );
}


// ================== Normal method: "jacobian''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC(CasADi::Function* obj, int x0, int x1)"
// call: "obj->jacobian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC(CasADi::Function* obj, int x0, int x1);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC(CasADi::Function* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_) );
}


// ================== Normal method: "jacobian'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC(CasADi::Function* obj, int x0)"
// call: "obj->jacobian(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC(CasADi::Function* obj, int x0);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC(CasADi::Function* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_) );
}


// ================== Normal method: "jacobian''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC(CasADi::Function* obj)"
// call: "obj->jacobian()"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC(CasADi::Function* obj);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC(CasADi::Function* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian() );
}


// ================== Normal method: "jacobian'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacobian''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_) );
}


// ================== Normal method: "jacobian'''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1)"
// call: "obj->jacobian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_) );
}


// ================== Normal method: "jacobian''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0)"
// call: "obj->jacobian(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_) );
}


// ================== Normal method: "jacobian'''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacobian''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_) );
}


// ================== Normal method: "jacobian'''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'''''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1)"
// call: "obj->jacobian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_) );
}


// ================== Normal method: "jacobian''''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''''''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacobian'''''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian'''''''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jacobian(x0_, x1_, x2_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_, x2_) );
}


// ================== Normal method: "jacobian''''''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacobian''''''''''''''"
// cWrapperName: "CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->jacobian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1);
CasADi::Function* CasADi__Function__jacobian_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->jacobian(x0_, x1_) );
}


// ================== Normal method: "setJacobian" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacobian"
// cWrapperName: "CasADi__Function__setJacobian"
// protoArgs: "(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(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2, int x3)"
// call: "obj->setJacobian(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Function__setJacobian(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2, int x3);
void CasADi__Function__setJacobian(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2, int x3){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,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_);
}


// ================== Normal method: "setJacobian'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacobian'"
// cWrapperName: "CasADi__Function__setJacobian_TIC"
// protoArgs: "(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setJacobian_TIC(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2)"
// call: "obj->setJacobian(x0_, x1_, x2_)"
extern "C"
    void CasADi__Function__setJacobian_TIC(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2);
void CasADi__Function__setJacobian_TIC(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setJacobian(x0_, x1_, x2_);
}


// ================== Normal method: "setJacobian''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacobian''"
// cWrapperName: "CasADi__Function__setJacobian_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, CasADi::Function* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setJacobian_TIC_TIC(CasADi::Function* obj, CasADi::Function* x0, int x1)"
// call: "obj->setJacobian(x0_, x1_)"
extern "C"
    void CasADi__Function__setJacobian_TIC_TIC(CasADi::Function* obj, CasADi::Function* x0, int x1);
void CasADi__Function__setJacobian_TIC_TIC(CasADi::Function* obj, CasADi::Function* x0, int x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    obj->setJacobian(x0_, x1_);
}


// ================== Normal method: "setJacobian'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacobian'''"
// cWrapperName: "CasADi__Function__setJacobian_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setJacobian_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Function* x0)"
// call: "obj->setJacobian(x0_)"
extern "C"
    void CasADi__Function__setJacobian_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Function* x0);
void CasADi__Function__setJacobian_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    obj->setJacobian(x0_);
}


// ================== Normal method: "gradient" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient"
// cWrapperName: "CasADi__Function__gradient"
// protoArgs: "(CasADi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient(CasADi::Function* obj, int x0, int x1)"
// call: "obj->gradient(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__gradient(CasADi::Function* obj, int x0, int x1);
CasADi::Function* CasADi__Function__gradient(CasADi::Function* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient(x0_, x1_) );
}


// ================== Normal method: "gradient'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient'"
// cWrapperName: "CasADi__Function__gradient_TIC"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient_TIC(CasADi::Function* obj, int x0)"
// call: "obj->gradient(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__gradient_TIC(CasADi::Function* obj, int x0);
CasADi::Function* CasADi__Function__gradient_TIC(CasADi::Function* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient(x0_) );
}


// ================== Normal method: "gradient''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient''"
// cWrapperName: "CasADi__Function__gradient_TIC_TIC"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient_TIC_TIC(CasADi::Function* obj)"
// call: "obj->gradient()"
extern "C"
    CasADi::Function* CasADi__Function__gradient_TIC_TIC(CasADi::Function* obj);
CasADi::Function* CasADi__Function__gradient_TIC_TIC(CasADi::Function* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient() );
}


// ================== Normal method: "gradient'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient'''"
// cWrapperName: "CasADi__Function__gradient_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1)"
// call: "obj->gradient(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1);
CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient(x0_, x1_) );
}


// ================== Normal method: "gradient''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient''''"
// cWrapperName: "CasADi__Function__gradient_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0)"
// call: "obj->gradient(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0);
CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient(x0_) );
}


// ================== Normal method: "gradient'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient'''''"
// cWrapperName: "CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1)"
// call: "obj->gradient(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1);
CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient(x0_, x1_) );
}


// ================== Normal method: "gradient''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::gradient''''''"
// cWrapperName: "CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->gradient(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1);
CasADi::Function* CasADi__Function__gradient_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->gradient(x0_, x1_) );
}


// ================== Normal method: "tangent" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent"
// cWrapperName: "CasADi__Function__tangent"
// protoArgs: "(CasADi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent(CasADi::Function* obj, int x0, int x1)"
// call: "obj->tangent(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__tangent(CasADi::Function* obj, int x0, int x1);
CasADi::Function* CasADi__Function__tangent(CasADi::Function* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent(x0_, x1_) );
}


// ================== Normal method: "tangent'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent'"
// cWrapperName: "CasADi__Function__tangent_TIC"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent_TIC(CasADi::Function* obj, int x0)"
// call: "obj->tangent(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__tangent_TIC(CasADi::Function* obj, int x0);
CasADi::Function* CasADi__Function__tangent_TIC(CasADi::Function* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent(x0_) );
}


// ================== Normal method: "tangent''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent''"
// cWrapperName: "CasADi__Function__tangent_TIC_TIC"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent_TIC_TIC(CasADi::Function* obj)"
// call: "obj->tangent()"
extern "C"
    CasADi::Function* CasADi__Function__tangent_TIC_TIC(CasADi::Function* obj);
CasADi::Function* CasADi__Function__tangent_TIC_TIC(CasADi::Function* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent() );
}


// ================== Normal method: "tangent'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent'''"
// cWrapperName: "CasADi__Function__tangent_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1)"
// call: "obj->tangent(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1);
CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent(x0_, x1_) );
}


// ================== Normal method: "tangent''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent''''"
// cWrapperName: "CasADi__Function__tangent_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0)"
// call: "obj->tangent(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0);
CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent(x0_) );
}


// ================== Normal method: "tangent'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent'''''"
// cWrapperName: "CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1)"
// call: "obj->tangent(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1);
CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent(x0_, x1_) );
}


// ================== Normal method: "tangent''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::tangent''''''"
// cWrapperName: "CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->tangent(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1);
CasADi::Function* CasADi__Function__tangent_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->tangent(x0_, x1_) );
}


// ================== Normal method: "hessian" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian"
// cWrapperName: "CasADi__Function__hessian"
// protoArgs: "(CasADi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian(CasADi::Function* obj, int x0, int x1)"
// call: "obj->hessian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__hessian(CasADi::Function* obj, int x0, int x1);
CasADi::Function* CasADi__Function__hessian(CasADi::Function* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian(x0_, x1_) );
}


// ================== Normal method: "hessian'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian'"
// cWrapperName: "CasADi__Function__hessian_TIC"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian_TIC(CasADi::Function* obj, int x0)"
// call: "obj->hessian(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__hessian_TIC(CasADi::Function* obj, int x0);
CasADi::Function* CasADi__Function__hessian_TIC(CasADi::Function* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian(x0_) );
}


// ================== Normal method: "hessian''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian''"
// cWrapperName: "CasADi__Function__hessian_TIC_TIC"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian_TIC_TIC(CasADi::Function* obj)"
// call: "obj->hessian()"
extern "C"
    CasADi::Function* CasADi__Function__hessian_TIC_TIC(CasADi::Function* obj);
CasADi::Function* CasADi__Function__hessian_TIC_TIC(CasADi::Function* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian() );
}


// ================== Normal method: "hessian'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian'''"
// cWrapperName: "CasADi__Function__hessian_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1)"
// call: "obj->hessian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1);
CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian(x0_, x1_) );
}


// ================== Normal method: "hessian''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian''''"
// cWrapperName: "CasADi__Function__hessian_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0)"
// call: "obj->hessian(x0_)"
extern "C"
    CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0);
CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian(x0_) );
}


// ================== Normal method: "hessian'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian'''''"
// cWrapperName: "CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1)"
// call: "obj->hessian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1);
CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian(x0_, x1_) );
}


// ================== Normal method: "hessian''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::hessian''''''"
// cWrapperName: "CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->hessian(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1);
CasADi::Function* CasADi__Function__hessian_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->hessian(x0_, x1_) );
}


// ================== Normal method: "fullJacobian" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::fullJacobian"
// cWrapperName: "CasADi__Function__fullJacobian"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__fullJacobian(CasADi::Function* obj)"
// call: "obj->fullJacobian()"
extern "C"
    CasADi::Function* CasADi__Function__fullJacobian(CasADi::Function* obj);
CasADi::Function* CasADi__Function__fullJacobian(CasADi::Function* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->fullJacobian() );
}


// ================== Normal method: "setFullJacobian" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setFullJacobian"
// cWrapperName: "CasADi__Function__setFullJacobian"
// protoArgs: "(CasADi::Function* obj, CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setFullJacobian(CasADi::Function* obj, CasADi::Function* x0)"
// call: "obj->setFullJacobian(x0_)"
extern "C"
    void CasADi__Function__setFullJacobian(CasADi::Function* obj, CasADi::Function* x0);
void CasADi__Function__setFullJacobian(CasADi::Function* obj, CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    obj->setFullJacobian(x0_);
}


// ================== Normal method: "call" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call"
// cWrapperName: "CasADi__Function__call"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass DMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__Function__call(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1, int x2)"
// call: "obj->call(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__Function__call(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1, int x2);
std::vector< CasADi::Matrix< double >* >* CasADi__Function__call(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1, int x2){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( obj->call(x0_, x1_, x2_) );
}


// ================== Normal method: "call'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call'"
// cWrapperName: "CasADi__Function__call_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec (CasadiClass DMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__Function__call_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1)"
// call: "obj->call(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__Function__call_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1);
std::vector< CasADi::Matrix< double >* >* CasADi__Function__call_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, int x1){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( obj->call(x0_, x1_) );
}


// ================== Normal method: "call''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call''"
// cWrapperName: "CasADi__Function__call_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass DMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__Function__call_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0)"
// call: "obj->call(x0_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__Function__call_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0);
std::vector< CasADi::Matrix< double >* >* CasADi__Function__call_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( obj->call(x0_) );
}


// ================== Normal method: "call'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call'''"
// cWrapperName: "CasADi__Function__call_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1, int x2)"
// call: "obj->call(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1, int x2);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1, int x2){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( obj->call(x0_, x1_, x2_) );
}


// ================== Normal method: "call''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call''''"
// cWrapperName: "CasADi__Function__call_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1)"
// call: "obj->call(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, int x1){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( obj->call(x0_, x1_) );
}


// ================== Normal method: "call'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call'''''"
// cWrapperName: "CasADi__Function__call_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "obj->call(x0_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( obj->call(x0_) );
}


// ================== Normal method: "call''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call''''''"
// cWrapperName: "CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1, int x2)"
// call: "obj->call(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1, int x2);
std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1, int x2){
    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);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( obj->call(x0_, x1_, x2_) );
}


// ================== Normal method: "call'''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call'''''''"
// cWrapperName: "CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1)"
// call: "obj->call(x0_, x1_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1);
std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0, int x1){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( obj->call(x0_, x1_) );
}


// ================== Normal method: "call''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::call''''''''"
// cWrapperName: "CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::MX* >* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0)"
// call: "obj->call(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0);
std::vector< CasADi::MX* >* CasADi__Function__call_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( obj->call(x0_) );
}


// ================== Normal method: "operator ()" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::operator ()"
// cWrapperName: "CasADi__Function__operator_call"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass DMatrix)
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__Function__operator_call(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0)"
// call: "obj->operator ()(x0_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__Function__operator_call(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0);
std::vector< CasADi::Matrix< double >* >* CasADi__Function__operator_call(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( obj->operator ()(x0_) );
}


// ================== Normal method: "operator ()'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::operator ()'"
// cWrapperName: "CasADi__Function__operator_call_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__operator_call_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "obj->operator ()(x0_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__operator_call_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__operator_call_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( obj->operator ()(x0_) );
}


// ================== Normal method: "operator ()''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::operator ()''"
// cWrapperName: "CasADi__Function__operator_call_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::MX* >* x0)"
// args: "(x0_)"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__Function__operator_call_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0)"
// call: "obj->operator ()(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__Function__operator_call_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0);
std::vector< CasADi::MX* >* CasADi__Function__operator_call_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( obj->operator ()(x0_) );
}


// ================== Normal method: "callDerivative" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative"
// cWrapperName: "CasADi__Function__callDerivative"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6, int x7)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__callDerivative(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6, int x7)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    void CasADi__Function__callDerivative(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6, int x7);
void CasADi__Function__callDerivative(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6, int x7){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< double > > x1_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x1);
    std::vector< std::vector< CasADi::Matrix< double > > > x2_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x2);
    std::vector< std::vector< CasADi::Matrix< double > > > x3_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x3);
    std::vector< std::vector< CasADi::Matrix< double > > > x4_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x4);
    std::vector< std::vector< CasADi::Matrix< double > > > x5_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::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_);
}


// ================== Normal method: "callDerivative'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative'"
// cWrapperName: "CasADi__Function__callDerivative_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__callDerivative_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    void CasADi__Function__callDerivative_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6);
void CasADi__Function__callDerivative_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5, int x6){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< double > > x1_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x1);
    std::vector< std::vector< CasADi::Matrix< double > > > x2_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x2);
    std::vector< std::vector< CasADi::Matrix< double > > > x3_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x3);
    std::vector< std::vector< CasADi::Matrix< double > > > x4_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x4);
    std::vector< std::vector< CasADi::Matrix< double > > > x5_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x5);
    bool x6_ = Marshaling<bool,int>::marshal(x6);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
}


// ================== Normal method: "callDerivative''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__callDerivative_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5);
void CasADi__Function__callDerivative_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< double >* >* x0, std::vector< CasADi::Matrix< double >* >* x1, std::vector< std::vector< CasADi::Matrix< double >* >* >* x2, std::vector< std::vector< CasADi::Matrix< double >* >* >* x3, std::vector< std::vector< CasADi::Matrix< double >* >* >* x4, std::vector< std::vector< CasADi::Matrix< double >* >* >* x5){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< double > > x1_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x1);
    std::vector< std::vector< CasADi::Matrix< double > > > x2_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x2);
    std::vector< std::vector< CasADi::Matrix< double > > > x3_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x3);
    std::vector< std::vector< CasADi::Matrix< double > > > x4_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x4);
    std::vector< std::vector< CasADi::Matrix< double > > > x5_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x5);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
}


// ================== Normal method: "callDerivative'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative'''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6, int x7)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__callDerivative_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6, int x7)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6, int x7);
void CasADi__Function__callDerivative_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6, int x7){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x2_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x2);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x3_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x3);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x4_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x4);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x5_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::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_);
}


// ================== Normal method: "callDerivative''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative''''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6);
void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5, int x6){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x2_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x2);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x3_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x3);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x4_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x4);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x5_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x5);
    bool x6_ = Marshaling<bool,int>::marshal(x6);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_, x6_);
}


// ================== Normal method: "callDerivative'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative'''''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5)"
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5)"
// call: "obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5);
void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x2, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x3, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x4, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x5){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x2_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x2);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x3_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x3);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x4_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x4);
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x5_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x5);

    obj->callDerivative(x0_, x1_, x2_, x3_, x4_, x5_);
}


// ================== Normal method: "callDerivative''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative''''''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC_TIC(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_TIC_TIC_TIC_TIC_TIC_TIC(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){
    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_);
}


// ================== Normal method: "callDerivative'''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative'''''''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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){
    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_);
}


// ================== Normal method: "callDerivative''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callDerivative''''''''"
// cWrapperName: "CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    void CasADi__Function__callDerivative_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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){
    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_);
}


// ================== Normal method: "callParallel" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::callParallel"
// cWrapperName: "CasADi__Function__callParallel"
// protoArgs: "(CasADi::Function* obj, std::vector< std::vector< CasADi::MX* >* >* x0)"
// args: "(x0_)"
// rettype: StdVec (StdVec (CasadiClass MX))
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__Function__callParallel(CasADi::Function* obj, std::vector< std::vector< CasADi::MX* >* >* x0)"
// call: "obj->callParallel(x0_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__Function__callParallel(CasADi::Function* obj, std::vector< std::vector< CasADi::MX* >* >* x0);
std::vector< std::vector< CasADi::MX* >* >* CasADi__Function__callParallel(CasADi::Function* obj, std::vector< std::vector< CasADi::MX* >* >* x0){
    std::vector< std::vector< CasADi::MX > > x0_ = Marshaling<std::vector< std::vector< CasADi::MX > >,std::vector< std::vector< CasADi::MX* >* >*>::marshal(x0);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( obj->callParallel(x0_) );
}


// ================== Normal method: "derivative" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::derivative"
// cWrapperName: "CasADi__Function__derivative"
// protoArgs: "(CasADi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__derivative(CasADi::Function* obj, int x0, int x1)"
// call: "obj->derivative(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__Function__derivative(CasADi::Function* obj, int x0, int x1);
CasADi::Function* CasADi__Function__derivative(CasADi::Function* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->derivative(x0_, x1_) );
}


// ================== Normal method: "setDerivative" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setDerivative"
// cWrapperName: "CasADi__Function__setDerivative"
// protoArgs: "(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setDerivative(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2)"
// call: "obj->setDerivative(x0_, x1_, x2_)"
extern "C"
    void CasADi__Function__setDerivative(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2);
void CasADi__Function__setDerivative(CasADi::Function* obj, CasADi::Function* x0, int x1, int x2){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setDerivative(x0_, x1_, x2_);
}


// ================== Normal method: "jacSparsity" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity"
// cWrapperName: "CasADi__Function__jacSparsity"
// protoArgs: "(CasADi::Function* obj, int x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity(CasADi::Function* obj, int x0, int x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity(CasADi::Function* obj, int x0, int x1, int x2, int x3);
CasADi::Sparsity* CasADi__Function__jacSparsity(CasADi::Function* obj, int x0, int x1, int x2, int x3){
    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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacSparsity'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'"
// cWrapperName: "CasADi__Function__jacSparsity_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC(CasADi::Function* obj, int x0, int x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC(CasADi::Function* obj, int x0, int x1, int x2);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC(CasADi::Function* obj, int x0, int x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_) );
}


// ================== Normal method: "jacSparsity''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC(CasADi::Function* obj, int x0, int x1)"
// call: "obj->jacSparsity(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC(CasADi::Function* obj, int x0, int x1);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC(CasADi::Function* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_) );
}


// ================== Normal method: "jacSparsity'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC(CasADi::Function* obj, int x0)"
// call: "obj->jacSparsity(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC(CasADi::Function* obj, int x0);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC(CasADi::Function* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_) );
}


// ================== Normal method: "jacSparsity''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC(CasADi::Function* obj)"
// call: "obj->jacSparsity()"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC(CasADi::Function* obj);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC(CasADi::Function* obj){

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity() );
}


// ================== Normal method: "jacSparsity'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,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);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacSparsity''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_) );
}


// ================== Normal method: "jacSparsity'''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1)"
// call: "obj->jacSparsity(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, int x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_) );
}


// ================== Normal method: "jacSparsity''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0)"
// call: "obj->jacSparsity(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_) );
}


// ================== Normal method: "jacSparsity'''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2, int x3){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacSparsity''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1, int x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_) );
}


// ================== Normal method: "jacSparsity'''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'''''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, int x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1)"
// call: "obj->jacSparsity(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_) );
}


// ================== Normal method: "jacSparsity''''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''''''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3)"
// call: "obj->jacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2, int x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_, x3_) );
}


// ================== Normal method: "jacSparsity'''''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity'''''''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2)"
// call: "obj->jacSparsity(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1, int x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_, x2_) );
}


// ================== Normal method: "jacSparsity''''''''''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::jacSparsity''''''''''''''"
// cWrapperName: "CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Sparsity
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1)"
// call: "obj->jacSparsity(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1);
CasADi::Sparsity* CasADi__Function__jacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( obj->jacSparsity(x0_, x1_) );
}


// ================== Normal method: "setJacSparsity" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity"
// cWrapperName: "CasADi__Function__setJacSparsity"
// protoArgs: "(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(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Function__setJacSparsity(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2, int x3);
void CasADi__Function__setJacSparsity(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2, int x3){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,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_);
}


// ================== Normal method: "setJacSparsity'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity'"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC"
// protoArgs: "(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setJacSparsity_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2);
void CasADi__Function__setJacSparsity_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, int x2){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
}


// ================== Normal method: "setJacSparsity''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity''"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC_TIC"
// protoArgs: "(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_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2, int x3);
void CasADi__Function__setJacSparsity_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2, int x3){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    obj->setJacSparsity(x0_, x1_, x2_, x3_);
}


// ================== Normal method: "setJacSparsity'''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity'''"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setJacSparsity_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2);
void CasADi__Function__setJacSparsity_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, int x2){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
}


// ================== Normal method: "setJacSparsity''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity''''"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2, int x3);
void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2, int x3){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    obj->setJacSparsity(x0_, x1_, x2_, x3_);
}


// ================== Normal method: "setJacSparsity'''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity'''''"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2);
void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, int x1, std::string* x2){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
}


// ================== Normal method: "setJacSparsity''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity''''''"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, std::string* x2, int x3)"
// call: "obj->setJacSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, std::string* x2, int x3);
void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, std::string* x2, int x3){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    obj->setJacSparsity(x0_, x1_, x2_, x3_);
}


// ================== Normal method: "setJacSparsity'''''''" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::setJacSparsity'''''''"
// cWrapperName: "CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, std::string* x2)"
// call: "obj->setJacSparsity(x0_, x1_, x2_)"
extern "C"
    void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, std::string* x2);
void CasADi__Function__setJacSparsity_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Function* obj, CasADi::Sparsity* x0, std::string* x1, std::string* x2){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);

    obj->setJacSparsity(x0_, x1_, x2_);
}


// ================== Normal method: "generateCode" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::generateCode"
// cWrapperName: "CasADi__Function__generateCode"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__generateCode(CasADi::Function* obj, std::string* x0)"
// call: "obj->generateCode(x0_)"
extern "C"
    void CasADi__Function__generateCode(CasADi::Function* obj, std::string* x0);
void CasADi__Function__generateCode(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->generateCode(x0_);
}


// ================== Normal method: "generateCode'" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::generateCode'"
// cWrapperName: "CasADi__Function__generateCode_TIC"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__Function__generateCode_TIC(CasADi::Function* obj)"
// call: "obj->generateCode()"
extern "C"
    std::string* CasADi__Function__generateCode_TIC(CasADi::Function* obj);
std::string* CasADi__Function__generateCode_TIC(CasADi::Function* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->generateCode() );
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::checkNode"
// cWrapperName: "CasADi__Function__checkNode"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Function__checkNode(CasADi::Function* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__Function__checkNode(CasADi::Function* obj);
int CasADi__Function__checkNode(CasADi::Function* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getStat" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::getStat"
// cWrapperName: "CasADi__Function__getStat"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass GenericType
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__Function__getStat(CasADi::Function* obj, std::string* x0)"
// call: "obj->getStat(x0_)"
extern "C"
    CasADi::GenericType* CasADi__Function__getStat(CasADi::Function* obj, std::string* x0);
CasADi::GenericType* CasADi__Function__getStat(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::GenericType*, CasADi::GenericType >::wrapReturn( obj->getStat(x0_) );
}


// ================== Normal method: "symbolicInput" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::symbolicInput"
// cWrapperName: "CasADi__Function__symbolicInput"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: StdVec (CasadiClass MX)
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__Function__symbolicInput(CasADi::Function* obj)"
// call: "obj->symbolicInput()"
extern "C"
    std::vector< CasADi::MX* >* CasADi__Function__symbolicInput(CasADi::Function* obj);
std::vector< CasADi::MX* >* CasADi__Function__symbolicInput(CasADi::Function* obj){

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( obj->symbolicInput() );
}


// ================== Normal method: "symbolicInputSX" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::symbolicInputSX"
// cWrapperName: "CasADi__Function__symbolicInputSX"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: StdVec (CasadiClass SX)
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__symbolicInputSX(CasADi::Function* obj)"
// call: "obj->symbolicInputSX()"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__symbolicInputSX(CasADi::Function* obj);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__Function__symbolicInputSX(CasADi::Function* obj){

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( obj->symbolicInputSX() );
}


// ================== Normal method: "spCanEvaluate" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::spCanEvaluate"
// cWrapperName: "CasADi__Function__spCanEvaluate"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__Function__spCanEvaluate(CasADi::Function* obj, int x0)"
// call: "obj->spCanEvaluate(x0_)"
extern "C"
    int CasADi__Function__spCanEvaluate(CasADi::Function* obj, int x0);
int CasADi__Function__spCanEvaluate(CasADi::Function* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( obj->spCanEvaluate(x0_) );
}


// ================== Normal method: "spInit" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::spInit"
// cWrapperName: "CasADi__Function__spInit"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__spInit(CasADi::Function* obj, int x0)"
// call: "obj->spInit(x0_)"
extern "C"
    void CasADi__Function__spInit(CasADi::Function* obj, int x0);
void CasADi__Function__spInit(CasADi::Function* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->spInit(x0_);
}


// ================== Normal method: "spEvaluate" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::spEvaluate"
// cWrapperName: "CasADi__Function__spEvaluate"
// protoArgs: "(CasADi::Function* obj, int x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__spEvaluate(CasADi::Function* obj, int x0)"
// call: "obj->spEvaluate(x0_)"
extern "C"
    void CasADi__Function__spEvaluate(CasADi::Function* obj, int x0);
void CasADi__Function__spEvaluate(CasADi::Function* obj, int x0){
    bool x0_ = Marshaling<bool,int>::marshal(x0);

    obj->spEvaluate(x0_);
}


// ================== Normal method: "addMonitor" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::addMonitor"
// cWrapperName: "CasADi__Function__addMonitor"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__addMonitor(CasADi::Function* obj, std::string* x0)"
// call: "obj->addMonitor(x0_)"
extern "C"
    void CasADi__Function__addMonitor(CasADi::Function* obj, std::string* x0);
void CasADi__Function__addMonitor(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->addMonitor(x0_);
}


// ================== Normal method: "removeMonitor" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::removeMonitor"
// cWrapperName: "CasADi__Function__removeMonitor"
// protoArgs: "(CasADi::Function* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__removeMonitor(CasADi::Function* obj, std::string* x0)"
// call: "obj->removeMonitor(x0_)"
extern "C"
    void CasADi__Function__removeMonitor(CasADi::Function* obj, std::string* x0);
void CasADi__Function__removeMonitor(CasADi::Function* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    obj->removeMonitor(x0_);
}


// ================== Normal method: "checkInputs" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function::checkInputs"
// cWrapperName: "CasADi__Function__checkInputs"
// protoArgs: "(CasADi::Function* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void CasADi__Function__checkInputs(CasADi::Function* obj)"
// call: "obj->checkInputs()"
extern "C"
    void CasADi__Function__checkInputs(CasADi::Function* obj);
void CasADi__Function__checkInputs(CasADi::Function* obj){

    obj->checkInputs();
}


// ================== Constructor method: "Function" ===============
// class: "CasADi::Function"
// cppName: "CasADi::Function"
// cWrapperName: "CasADi__Function__Function"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__Function__Function()"
// call: "CasADi::Function()"
extern "C"
    CasADi::Function* CasADi__Function__Function();
CasADi::Function* CasADi__Function__Function(){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( CasADi::Function() );
}



// ================== delete CasadiClass SOCPSolver===============
// classType: CasadiClass SOCPSolver
extern "C"
    void delete_CasADi__SOCPSolver(CasADi::SOCPSolver* obj);
void delete_CasADi__SOCPSolver(CasADi::SOCPSolver* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::SOCPSolver"
// cppName: "CasADi::SOCPSolver::checkNode"
// cWrapperName: "CasADi__SOCPSolver__checkNode"
// protoArgs: "(CasADi::SOCPSolver* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__SOCPSolver__checkNode(CasADi::SOCPSolver* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__SOCPSolver__checkNode(CasADi::SOCPSolver* obj);
int CasADi__SOCPSolver__checkNode(CasADi::SOCPSolver* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Constructor method: "SOCPSolver" ===============
// class: "CasADi::SOCPSolver"
// cppName: "CasADi::SOCPSolver"
// cWrapperName: "CasADi__SOCPSolver__SOCPSolver"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass SOCPSolver
// cWrapperRetType: "CasADi::SOCPSolver*"
// proto: "CasADi::SOCPSolver* CasADi__SOCPSolver__SOCPSolver()"
// call: "CasADi::SOCPSolver()"
extern "C"
    CasADi::SOCPSolver* CasADi__SOCPSolver__SOCPSolver();
CasADi::SOCPSolver* CasADi__SOCPSolver__SOCPSolver(){

    return WrapReturn< CasADi::SOCPSolver*, CasADi::SOCPSolver >::wrapReturn( CasADi::SOCPSolver() );
}


// ================== delete CasadiClass DerivativeGenerator===============
// classType: CasadiClass DerivativeGenerator
extern "C"
    void delete_CasADi__DerivativeGenerator(CasADi::DerivativeGenerator* obj);
void delete_CasADi__DerivativeGenerator(CasADi::DerivativeGenerator* obj){
    delete obj;
}

// ================== Constructor method: "DerivativeGenerator" ===============
// class: "CasADi::DerivativeGenerator"
// cppName: "CasADi::DerivativeGenerator"
// cWrapperName: "CasADi__DerivativeGenerator__DerivativeGenerator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass DerivativeGenerator
// cWrapperRetType: "CasADi::DerivativeGenerator*"
// proto: "CasADi::DerivativeGenerator* CasADi__DerivativeGenerator__DerivativeGenerator()"
// call: "CasADi::DerivativeGenerator()"
extern "C"
    CasADi::DerivativeGenerator* CasADi__DerivativeGenerator__DerivativeGenerator();
CasADi::DerivativeGenerator* CasADi__DerivativeGenerator__DerivativeGenerator(){

    return WrapReturn< CasADi::DerivativeGenerator*, CasADi::DerivativeGenerator >::wrapReturn( CasADi::DerivativeGenerator() );
}


// ================== delete CasadiClass SOCPStructure===============
// classType: CasadiClass SOCPStructure
extern "C"
    void delete_CasADi__SOCPStructIOSchemeVector_CasADi__Sparsity_(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* obj);
void delete_CasADi__SOCPStructIOSchemeVector_CasADi__Sparsity_(CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* obj){
    delete obj;
}

// ================== Constructor method: "SOCPStructure" ===============
// class: "CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >"
// cppName: "CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >"
// cWrapperName: "CasADi__SOCPStructIOSchemeVector_CasADi__Sparsity___SOCPStructure"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass SOCPStructure
// cWrapperRetType: "CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >*"
// proto: "CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SOCPStructIOSchemeVector_CasADi__Sparsity___SOCPStructure(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >(x0_)"
extern "C"
    CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SOCPStructIOSchemeVector_CasADi__Sparsity___SOCPStructure(std::vector< CasADi::Sparsity* >* x0);
CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >* CasADi__SOCPStructIOSchemeVector_CasADi__Sparsity___SOCPStructure(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >*, CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity > >::wrapReturn( CasADi::SOCPStructIOSchemeVector< CasADi::Sparsity >(x0_) );
}


// ================== delete CasadiClass ImplicitFunction===============
// classType: CasadiClass ImplicitFunction
extern "C"
    void delete_CasADi__ImplicitFunction(CasADi::ImplicitFunction* obj);
void delete_CasADi__ImplicitFunction(CasADi::ImplicitFunction* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::ImplicitFunction"
// cppName: "CasADi::ImplicitFunction::checkNode"
// cWrapperName: "CasADi__ImplicitFunction__checkNode"
// protoArgs: "(CasADi::ImplicitFunction* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__ImplicitFunction__checkNode(CasADi::ImplicitFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__ImplicitFunction__checkNode(CasADi::ImplicitFunction* obj);
int CasADi__ImplicitFunction__checkNode(CasADi::ImplicitFunction* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "getF" ===============
// class: "CasADi::ImplicitFunction"
// cppName: "CasADi::ImplicitFunction::getF"
// cWrapperName: "CasADi__ImplicitFunction__getF"
// protoArgs: "(CasADi::ImplicitFunction* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__ImplicitFunction__getF(CasADi::ImplicitFunction* obj)"
// call: "obj->getF()"
extern "C"
    CasADi::Function* CasADi__ImplicitFunction__getF(CasADi::ImplicitFunction* obj);
CasADi::Function* CasADi__ImplicitFunction__getF(CasADi::ImplicitFunction* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getF() );
}


// ================== Normal method: "getJac" ===============
// class: "CasADi::ImplicitFunction"
// cppName: "CasADi::ImplicitFunction::getJac"
// cWrapperName: "CasADi__ImplicitFunction__getJac"
// protoArgs: "(CasADi::ImplicitFunction* obj)"
// args: "()"
// rettype: CasadiClass Function
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__ImplicitFunction__getJac(CasADi::ImplicitFunction* obj)"
// call: "obj->getJac()"
extern "C"
    CasADi::Function* CasADi__ImplicitFunction__getJac(CasADi::ImplicitFunction* obj);
CasADi::Function* CasADi__ImplicitFunction__getJac(CasADi::ImplicitFunction* obj){

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( obj->getJac() );
}


// ================== Normal method: "getLinsol" ===============
// class: "CasADi::ImplicitFunction"
// cppName: "CasADi::ImplicitFunction::getLinsol"
// cWrapperName: "CasADi__ImplicitFunction__getLinsol"
// protoArgs: "(CasADi::ImplicitFunction* obj)"
// args: "()"
// rettype: CasadiClass LinearSolver
// cWrapperRetType: "CasADi::LinearSolver*"
// proto: "CasADi::LinearSolver* CasADi__ImplicitFunction__getLinsol(CasADi::ImplicitFunction* obj)"
// call: "obj->getLinsol()"
extern "C"
    CasADi::LinearSolver* CasADi__ImplicitFunction__getLinsol(CasADi::ImplicitFunction* obj);
CasADi::LinearSolver* CasADi__ImplicitFunction__getLinsol(CasADi::ImplicitFunction* obj){

    return WrapReturn< CasADi::LinearSolver*, CasADi::LinearSolver >::wrapReturn( obj->getLinsol() );
}


// ================== delete CasadiClass CVodesIntegrator===============
// classType: CasadiClass CVodesIntegrator
extern "C"
    void delete_CasADi__CVodesIntegrator(CasADi::CVodesIntegrator* obj);
void delete_CasADi__CVodesIntegrator(CasADi::CVodesIntegrator* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::CVodesIntegrator"
// cppName: "CasADi::CVodesIntegrator::checkNode"
// cWrapperName: "CasADi__CVodesIntegrator__checkNode"
// protoArgs: "(CasADi::CVodesIntegrator* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__CVodesIntegrator__checkNode(CasADi::CVodesIntegrator* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__CVodesIntegrator__checkNode(CasADi::CVodesIntegrator* obj);
int CasADi__CVodesIntegrator__checkNode(CasADi::CVodesIntegrator* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::CVodesIntegrator"
// cppName: "CasADi::CVodesIntegrator::creator"
// cWrapperName: "CasADi__CVodesIntegrator__creator"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass Integrator
// cWrapperRetType: "CasADi::Integrator*"
// proto: "CasADi::Integrator* CasADi__CVodesIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::CVodesIntegrator::creator(x0_, x1_)"
extern "C"
    CasADi::Integrator* CasADi__CVodesIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1);
CasADi::Integrator* CasADi__CVodesIntegrator__creator(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::Integrator*, CasADi::Integrator >::wrapReturn( CasADi::CVodesIntegrator::creator(x0_, x1_) );
}


// ================== Constructor method: "CVodesIntegrator" ===============
// class: "CasADi::CVodesIntegrator"
// cppName: "CasADi::CVodesIntegrator"
// cWrapperName: "CasADi__CVodesIntegrator__CVodesIntegrator"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass CVodesIntegrator
// cWrapperRetType: "CasADi::CVodesIntegrator*"
// proto: "CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator()"
// call: "CasADi::CVodesIntegrator()"
extern "C"
    CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator();
CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator(){

    return WrapReturn< CasADi::CVodesIntegrator*, CasADi::CVodesIntegrator >::wrapReturn( CasADi::CVodesIntegrator() );
}


// ================== Constructor method: "CVodesIntegrator'" ===============
// class: "CasADi::CVodesIntegrator"
// cppName: "CasADi::CVodesIntegrator"
// cWrapperName: "CasADi__CVodesIntegrator__CVodesIntegrator_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::Function* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass CVodesIntegrator
// cWrapperRetType: "CasADi::CVodesIntegrator*"
// proto: "CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1)"
// call: "CasADi::CVodesIntegrator(x0_, x1_)"
extern "C"
    CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1);
CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator_TIC(CasADi::Function* x0, CasADi::Function* x1){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);
    CasADi::Function const & x1_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x1);

    return WrapReturn< CasADi::CVodesIntegrator*, CasADi::CVodesIntegrator >::wrapReturn( CasADi::CVodesIntegrator(x0_, x1_) );
}


// ================== Constructor method: "CVodesIntegrator''" ===============
// class: "CasADi::CVodesIntegrator"
// cppName: "CasADi::CVodesIntegrator"
// cWrapperName: "CasADi__CVodesIntegrator__CVodesIntegrator_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass CVodesIntegrator
// cWrapperRetType: "CasADi::CVodesIntegrator*"
// proto: "CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::CVodesIntegrator(x0_)"
extern "C"
    CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator_TIC_TIC(CasADi::Function* x0);
CasADi::CVodesIntegrator* CasADi__CVodesIntegrator__CVodesIntegrator_TIC_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::CVodesIntegrator*, CasADi::CVodesIntegrator >::wrapReturn( CasADi::CVodesIntegrator(x0_) );
}


// ================== delete CasadiClass IndexList===============
// classType: CasadiClass IndexList
extern "C"
    void delete_CasADi__IndexList(CasADi::IndexList* obj);
void delete_CasADi__IndexList(CasADi::IndexList* obj){
    delete obj;
}

// ================== Normal method: "getAll" ===============
// class: "CasADi::IndexList"
// cppName: "CasADi::IndexList::getAll"
// cWrapperName: "CasADi__IndexList__getAll"
// protoArgs: "(CasADi::IndexList* obj, int x0)"
// args: "(x0_)"
// rettype: StdVec CInt
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__IndexList__getAll(CasADi::IndexList* obj, int x0)"
// call: "obj->getAll(x0_)"
extern "C"
    std::vector< int >* CasADi__IndexList__getAll(CasADi::IndexList* obj, int x0);
std::vector< int >* CasADi__IndexList__getAll(CasADi::IndexList* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( obj->getAll(x0_) );
}


// ================== Constructor method: "IndexList" ===============
// class: "CasADi::IndexList"
// cppName: "CasADi::IndexList"
// cWrapperName: "CasADi__IndexList__IndexList"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IndexList
// cWrapperRetType: "CasADi::IndexList*"
// proto: "CasADi::IndexList* CasADi__IndexList__IndexList()"
// call: "CasADi::IndexList()"
extern "C"
    CasADi::IndexList* CasADi__IndexList__IndexList();
CasADi::IndexList* CasADi__IndexList__IndexList(){

    return WrapReturn< CasADi::IndexList*, CasADi::IndexList >::wrapReturn( CasADi::IndexList() );
}


// ================== Constructor method: "IndexList'" ===============
// class: "CasADi::IndexList"
// cppName: "CasADi::IndexList"
// cWrapperName: "CasADi__IndexList__IndexList_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: CasadiClass IndexList
// cWrapperRetType: "CasADi::IndexList*"
// proto: "CasADi::IndexList* CasADi__IndexList__IndexList_TIC(int x0)"
// call: "CasADi::IndexList(x0_)"
extern "C"
    CasADi::IndexList* CasADi__IndexList__IndexList_TIC(int x0);
CasADi::IndexList* CasADi__IndexList__IndexList_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< CasADi::IndexList*, CasADi::IndexList >::wrapReturn( CasADi::IndexList(x0_) );
}


// ================== Constructor method: "IndexList''" ===============
// class: "CasADi::IndexList"
// cppName: "CasADi::IndexList"
// cWrapperName: "CasADi__IndexList__IndexList_TIC_TIC"
// protoArgs: "(std::vector< int >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IndexList
// cWrapperRetType: "CasADi::IndexList*"
// proto: "CasADi::IndexList* CasADi__IndexList__IndexList_TIC_TIC(std::vector< int >* x0)"
// call: "CasADi::IndexList(x0_)"
extern "C"
    CasADi::IndexList* CasADi__IndexList__IndexList_TIC_TIC(std::vector< int >* x0);
CasADi::IndexList* CasADi__IndexList__IndexList_TIC_TIC(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< CasADi::IndexList*, CasADi::IndexList >::wrapReturn( CasADi::IndexList(x0_) );
}


// ================== Constructor method: "IndexList'''" ===============
// class: "CasADi::IndexList"
// cppName: "CasADi::IndexList"
// cWrapperName: "CasADi__IndexList__IndexList_TIC_TIC_TIC"
// protoArgs: "(CasADi::Slice* x0)"
// args: "(x0_)"
// rettype: CasadiClass IndexList
// cWrapperRetType: "CasADi::IndexList*"
// proto: "CasADi::IndexList* CasADi__IndexList__IndexList_TIC_TIC_TIC(CasADi::Slice* x0)"
// call: "CasADi::IndexList(x0_)"
extern "C"
    CasADi::IndexList* CasADi__IndexList__IndexList_TIC_TIC_TIC(CasADi::Slice* x0);
CasADi::IndexList* CasADi__IndexList__IndexList_TIC_TIC_TIC(CasADi::Slice* x0){
    CasADi::Slice const & x0_ = Marshaling<CasADi::Slice const &,CasADi::Slice*>::marshal(x0);

    return WrapReturn< CasADi::IndexList*, CasADi::IndexList >::wrapReturn( CasADi::IndexList(x0_) );
}


// ================== delete CasadiClass StabilizedSQPMethod===============
// classType: CasadiClass StabilizedSQPMethod
extern "C"
    void delete_CasADi__StabilizedSQPMethod(CasADi::StabilizedSQPMethod* obj);
void delete_CasADi__StabilizedSQPMethod(CasADi::StabilizedSQPMethod* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::StabilizedSQPMethod"
// cppName: "CasADi::StabilizedSQPMethod::checkNode"
// cWrapperName: "CasADi__StabilizedSQPMethod__checkNode"
// protoArgs: "(CasADi::StabilizedSQPMethod* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__StabilizedSQPMethod__checkNode(CasADi::StabilizedSQPMethod* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__StabilizedSQPMethod__checkNode(CasADi::StabilizedSQPMethod* obj);
int CasADi__StabilizedSQPMethod__checkNode(CasADi::StabilizedSQPMethod* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Static method: "creator" ===============
// class: "CasADi::StabilizedSQPMethod"
// cppName: "CasADi::StabilizedSQPMethod::creator"
// cWrapperName: "CasADi__StabilizedSQPMethod__creator"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass NLPSolver
// cWrapperRetType: "CasADi::NLPSolver*"
// proto: "CasADi::NLPSolver* CasADi__StabilizedSQPMethod__creator(CasADi::Function* x0)"
// call: "CasADi::StabilizedSQPMethod::creator(x0_)"
extern "C"
    CasADi::NLPSolver* CasADi__StabilizedSQPMethod__creator(CasADi::Function* x0);
CasADi::NLPSolver* CasADi__StabilizedSQPMethod__creator(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::NLPSolver*, CasADi::NLPSolver >::wrapReturn( CasADi::StabilizedSQPMethod::creator(x0_) );
}


// ================== Constructor method: "StabilizedSQPMethod" ===============
// class: "CasADi::StabilizedSQPMethod"
// cppName: "CasADi::StabilizedSQPMethod"
// cWrapperName: "CasADi__StabilizedSQPMethod__StabilizedSQPMethod"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass StabilizedSQPMethod
// cWrapperRetType: "CasADi::StabilizedSQPMethod*"
// proto: "CasADi::StabilizedSQPMethod* CasADi__StabilizedSQPMethod__StabilizedSQPMethod()"
// call: "CasADi::StabilizedSQPMethod()"
extern "C"
    CasADi::StabilizedSQPMethod* CasADi__StabilizedSQPMethod__StabilizedSQPMethod();
CasADi::StabilizedSQPMethod* CasADi__StabilizedSQPMethod__StabilizedSQPMethod(){

    return WrapReturn< CasADi::StabilizedSQPMethod*, CasADi::StabilizedSQPMethod >::wrapReturn( CasADi::StabilizedSQPMethod() );
}


// ================== Constructor method: "StabilizedSQPMethod'" ===============
// class: "CasADi::StabilizedSQPMethod"
// cppName: "CasADi::StabilizedSQPMethod"
// cWrapperName: "CasADi__StabilizedSQPMethod__StabilizedSQPMethod_TIC"
// protoArgs: "(CasADi::Function* x0)"
// args: "(x0_)"
// rettype: CasadiClass StabilizedSQPMethod
// cWrapperRetType: "CasADi::StabilizedSQPMethod*"
// proto: "CasADi::StabilizedSQPMethod* CasADi__StabilizedSQPMethod__StabilizedSQPMethod_TIC(CasADi::Function* x0)"
// call: "CasADi::StabilizedSQPMethod(x0_)"
extern "C"
    CasADi::StabilizedSQPMethod* CasADi__StabilizedSQPMethod__StabilizedSQPMethod_TIC(CasADi::Function* x0);
CasADi::StabilizedSQPMethod* CasADi__StabilizedSQPMethod__StabilizedSQPMethod_TIC(CasADi::Function* x0){
    CasADi::Function const & x0_ = Marshaling<CasADi::Function const &,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::StabilizedSQPMethod*, CasADi::StabilizedSQPMethod >::wrapReturn( CasADi::StabilizedSQPMethod(x0_) );
}


// ================== delete CasadiClass IOScheme===============
// classType: CasadiClass IOScheme
extern "C"
    void delete_CasADi__IOScheme(CasADi::IOScheme* obj);
void delete_CasADi__IOScheme(CasADi::IOScheme* obj){
    delete obj;
}

// ================== Normal method: "checkNode" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::checkNode"
// cWrapperName: "CasADi__IOScheme__checkNode"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__IOScheme__checkNode(CasADi::IOScheme* obj)"
// call: "obj->checkNode()"
extern "C"
    int CasADi__IOScheme__checkNode(CasADi::IOScheme* obj);
int CasADi__IOScheme__checkNode(CasADi::IOScheme* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->checkNode() );
}


// ================== Normal method: "name" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::name"
// cWrapperName: "CasADi__IOScheme__name"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__name(CasADi::IOScheme* obj)"
// call: "obj->name()"
extern "C"
    std::string* CasADi__IOScheme__name(CasADi::IOScheme* obj);
std::string* CasADi__IOScheme__name(CasADi::IOScheme* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->name() );
}


// ================== Normal method: "entryNames" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::entryNames"
// cWrapperName: "CasADi__IOScheme__entryNames"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__entryNames(CasADi::IOScheme* obj)"
// call: "obj->entryNames()"
extern "C"
    std::string* CasADi__IOScheme__entryNames(CasADi::IOScheme* obj);
std::string* CasADi__IOScheme__entryNames(CasADi::IOScheme* obj){

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->entryNames() );
}


// ================== Normal method: "index" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::index"
// cWrapperName: "CasADi__IOScheme__index"
// protoArgs: "(CasADi::IOScheme* obj, std::string* x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOScheme__index(CasADi::IOScheme* obj, std::string* x0)"
// call: "obj->index(x0_)"
extern "C"
    int CasADi__IOScheme__index(CasADi::IOScheme* obj, std::string* x0);
int CasADi__IOScheme__index(CasADi::IOScheme* obj, std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->index(x0_) );
}


// ================== Normal method: "size" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::size"
// cWrapperName: "CasADi__IOScheme__size"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOScheme__size(CasADi::IOScheme* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__IOScheme__size(CasADi::IOScheme* obj);
int CasADi__IOScheme__size(CasADi::IOScheme* obj){

    return WrapReturn< int, int >::wrapReturn( obj->size() );
}


// ================== Normal method: "entry" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::entry"
// cWrapperName: "CasADi__IOScheme__entry"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__entry(CasADi::IOScheme* obj, int x0)"
// call: "obj->entry(x0_)"
extern "C"
    std::string* CasADi__IOScheme__entry(CasADi::IOScheme* obj, int x0);
std::string* CasADi__IOScheme__entry(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->entry(x0_) );
}


// ================== Normal method: "entryLabel" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::entryLabel"
// cWrapperName: "CasADi__IOScheme__entryLabel"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__entryLabel(CasADi::IOScheme* obj, int x0)"
// call: "obj->entryLabel(x0_)"
extern "C"
    std::string* CasADi__IOScheme__entryLabel(CasADi::IOScheme* obj, int x0);
std::string* CasADi__IOScheme__entryLabel(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->entryLabel(x0_) );
}


// ================== Normal method: "entryEnum" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::entryEnum"
// cWrapperName: "CasADi__IOScheme__entryEnum"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__entryEnum(CasADi::IOScheme* obj, int x0)"
// call: "obj->entryEnum(x0_)"
extern "C"
    std::string* CasADi__IOScheme__entryEnum(CasADi::IOScheme* obj, int x0);
std::string* CasADi__IOScheme__entryEnum(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->entryEnum(x0_) );
}


// ================== Normal method: "describeInput" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::describeInput"
// cWrapperName: "CasADi__IOScheme__describeInput"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__describeInput(CasADi::IOScheme* obj, int x0)"
// call: "obj->describeInput(x0_)"
extern "C"
    std::string* CasADi__IOScheme__describeInput(CasADi::IOScheme* obj, int x0);
std::string* CasADi__IOScheme__describeInput(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->describeInput(x0_) );
}


// ================== Normal method: "describeOutput" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::describeOutput"
// cWrapperName: "CasADi__IOScheme__describeOutput"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__describeOutput(CasADi::IOScheme* obj, int x0)"
// call: "obj->describeOutput(x0_)"
extern "C"
    std::string* CasADi__IOScheme__describeOutput(CasADi::IOScheme* obj, int x0);
std::string* CasADi__IOScheme__describeOutput(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->describeOutput(x0_) );
}


// ================== Normal method: "describe" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::describe"
// cWrapperName: "CasADi__IOScheme__describe"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__IOScheme__describe(CasADi::IOScheme* obj, int x0)"
// call: "obj->describe(x0_)"
extern "C"
    std::string* CasADi__IOScheme__describe(CasADi::IOScheme* obj, int x0);
std::string* CasADi__IOScheme__describe(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( obj->describe(x0_) );
}


// ================== Normal method: "known" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::known"
// cWrapperName: "CasADi__IOScheme__known"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: CBool
// cWrapperRetType: "int"
// proto: "int CasADi__IOScheme__known(CasADi::IOScheme* obj)"
// call: "obj->known()"
extern "C"
    int CasADi__IOScheme__known(CasADi::IOScheme* obj);
int CasADi__IOScheme__known(CasADi::IOScheme* obj){

    return WrapReturn< int, bool >::wrapReturn( obj->known() );
}


// ================== Normal method: "compatibleSize" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::compatibleSize"
// cWrapperName: "CasADi__IOScheme__compatibleSize"
// protoArgs: "(CasADi::IOScheme* obj, int x0)"
// args: "(x0_)"
// rettype: CInt
// cWrapperRetType: "int"
// proto: "int CasADi__IOScheme__compatibleSize(CasADi::IOScheme* obj, int x0)"
// call: "obj->compatibleSize(x0_)"
extern "C"
    int CasADi__IOScheme__compatibleSize(CasADi::IOScheme* obj, int x0);
int CasADi__IOScheme__compatibleSize(CasADi::IOScheme* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( obj->compatibleSize(x0_) );
}


// ================== Constructor method: "IOScheme" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme"
// protoArgs: "()"
// args: "()"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme()"
// call: "CasADi::IOScheme()"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme();
CasADi::IOScheme* CasADi__IOScheme__IOScheme(){

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme() );
}


// ================== Constructor method: "IOScheme'" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// args: "(x0_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC(CasADi::InputOutputScheme x0)"
// call: "CasADi::IOScheme(x0_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC(CasADi::InputOutputScheme x0);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC(CasADi::InputOutputScheme x0){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_) );
}


// ================== Constructor method: "IOScheme''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC"
// protoArgs: "(std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector< std::string* >* x0, std::vector< std::string* >* x1)"
// call: "CasADi::IOScheme(x0_, x1_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector< std::string* >* x0, std::vector< std::string* >* x1);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector< std::string* >* x0, std::vector< std::string* >* x1){
    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);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_) );
}


// ================== Constructor method: "IOScheme'''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC"
// protoArgs: "(std::vector< std::string* >* x0)"
// args: "(x0_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC(std::vector< std::string* >* x0)"
// call: "CasADi::IOScheme(x0_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC(std::vector< std::string* >* x0);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC(std::vector< std::string* >* x0){
    std::vector< std::string > x0_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x0);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_) );
}


// ================== Constructor method: "IOScheme''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC(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){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);
    std::string const & x14_ = Marshaling<std::string const &,std::string*>::marshal(x14);
    std::string const & x15_ = Marshaling<std::string const &,std::string*>::marshal(x15);
    std::string const & x16_ = Marshaling<std::string const &,std::string*>::marshal(x16);
    std::string const & x17_ = Marshaling<std::string const &,std::string*>::marshal(x17);
    std::string const & x18_ = Marshaling<std::string const &,std::string*>::marshal(x18);
    std::string const & x19_ = Marshaling<std::string const &,std::string*>::marshal(x19);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_, x19_) );
}


// ================== Constructor method: "IOScheme'''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);
    std::string const & x14_ = Marshaling<std::string const &,std::string*>::marshal(x14);
    std::string const & x15_ = Marshaling<std::string const &,std::string*>::marshal(x15);
    std::string const & x16_ = Marshaling<std::string const &,std::string*>::marshal(x16);
    std::string const & x17_ = Marshaling<std::string const &,std::string*>::marshal(x17);
    std::string const & x18_ = Marshaling<std::string const &,std::string*>::marshal(x18);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_, x18_) );
}


// ================== Constructor method: "IOScheme''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);
    std::string const & x14_ = Marshaling<std::string const &,std::string*>::marshal(x14);
    std::string const & x15_ = Marshaling<std::string const &,std::string*>::marshal(x15);
    std::string const & x16_ = Marshaling<std::string const &,std::string*>::marshal(x16);
    std::string const & x17_ = Marshaling<std::string const &,std::string*>::marshal(x17);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_, x17_) );
}


// ================== Constructor method: "IOScheme'''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);
    std::string const & x14_ = Marshaling<std::string const &,std::string*>::marshal(x14);
    std::string const & x15_ = Marshaling<std::string const &,std::string*>::marshal(x15);
    std::string const & x16_ = Marshaling<std::string const &,std::string*>::marshal(x16);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_, x16_) );
}


// ================== Constructor method: "IOScheme''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);
    std::string const & x14_ = Marshaling<std::string const &,std::string*>::marshal(x14);
    std::string const & x15_ = Marshaling<std::string const &,std::string*>::marshal(x15);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_) );
}


// ================== Constructor method: "IOScheme'''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);
    std::string const & x14_ = Marshaling<std::string const &,std::string*>::marshal(x14);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_) );
}


// ================== Constructor method: "IOScheme''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);
    std::string const & x13_ = Marshaling<std::string const &,std::string*>::marshal(x13);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_) );
}


// ================== Constructor method: "IOScheme'''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);
    std::string const & x12_ = Marshaling<std::string const &,std::string*>::marshal(x12);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_) );
}


// ================== Constructor method: "IOScheme''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);
    std::string const & x11_ = Marshaling<std::string const &,std::string*>::marshal(x11);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_) );
}


// ================== Constructor method: "IOScheme'''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);
    std::string const & x10_ = Marshaling<std::string const &,std::string*>::marshal(x10);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_) );
}


// ================== Constructor method: "IOScheme''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);
    std::string const & x9_ = Marshaling<std::string const &,std::string*>::marshal(x9);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_) );
}


// ================== Constructor method: "IOScheme'''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);
    std::string const & x8_ = Marshaling<std::string const &,std::string*>::marshal(x8);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_) );
}


// ================== Constructor method: "IOScheme''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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 const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);
    std::string const & x7_ = Marshaling<std::string const &,std::string*>::marshal(x7);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_, x7_) );
}


// ================== Constructor method: "IOScheme'''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5, std::string* x6){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);
    std::string const & x6_ = Marshaling<std::string const &,std::string*>::marshal(x6);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_, x6_) );
}


// ================== Constructor method: "IOScheme''''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(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: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(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_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4, std::string* x5){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);
    std::string const & x5_ = Marshaling<std::string const &,std::string*>::marshal(x5);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_, x5_) );
}


// ================== Constructor method: "IOScheme'''''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4)"
// call: "CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3, std::string* x4){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Constructor method: "IOScheme''''''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, std::string* x1, std::string* x2, std::string* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3)"
// call: "CasADi::IOScheme(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2, std::string* x3){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "IOScheme'''''''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, std::string* x1, std::string* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2)"
// call: "CasADi::IOScheme(x0_, x1_, x2_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1, std::string* x2){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);
    std::string const & x2_ = Marshaling<std::string const &,std::string*>::marshal(x2);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_, x2_) );
}


// ================== Constructor method: "IOScheme''''''''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1)"
// call: "CasADi::IOScheme(x0_, x1_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, std::string* x1){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_, x1_) );
}


// ================== Constructor method: "IOScheme'''''''''''''''''''''''" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: CasadiClass IOScheme
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0)"
// call: "CasADi::IOScheme(x0_)"
extern "C"
    CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0);
CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0){
    std::string const & x0_ = Marshaling<std::string const &,std::string*>::marshal(x0);

    return WrapReturn< CasADi::IOScheme*, CasADi::IOScheme >::wrapReturn( CasADi::IOScheme(x0_) );
}


// ================== function "CasADi::getSchemeEntryName" ===============
// cppName: "CasADi::getSchemeEntryName"
// cWrapperName: "CasADi__getSchemeEntryName"
// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"
// params: [CasadiEnum InputOutputScheme,CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getSchemeEntryName(CasADi::InputOutputScheme x0, int x1)"
// call: "CasADi::getSchemeEntryName(x0_, x1_)"
extern "C"
    std::string* CasADi__getSchemeEntryName(CasADi::InputOutputScheme x0, int x1);
std::string* CasADi__getSchemeEntryName(CasADi::InputOutputScheme x0, int x1){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getSchemeEntryName(x0_, x1_) );
}


// ================== function "CasADi::getSchemeEntryDoc" ===============
// cppName: "CasADi::getSchemeEntryDoc"
// cWrapperName: "CasADi__getSchemeEntryDoc"
// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"
// params: [CasadiEnum InputOutputScheme,CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getSchemeEntryDoc(CasADi::InputOutputScheme x0, int x1)"
// call: "CasADi::getSchemeEntryDoc(x0_, x1_)"
extern "C"
    std::string* CasADi__getSchemeEntryDoc(CasADi::InputOutputScheme x0, int x1);
std::string* CasADi__getSchemeEntryDoc(CasADi::InputOutputScheme x0, int x1){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getSchemeEntryDoc(x0_, x1_) );
}


// ================== function "CasADi::getSchemeEntryEnumName" ===============
// cppName: "CasADi::getSchemeEntryEnumName"
// cWrapperName: "CasADi__getSchemeEntryEnumName"
// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"
// params: [CasadiEnum InputOutputScheme,CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getSchemeEntryEnumName(CasADi::InputOutputScheme x0, int x1)"
// call: "CasADi::getSchemeEntryEnumName(x0_, x1_)"
extern "C"
    std::string* CasADi__getSchemeEntryEnumName(CasADi::InputOutputScheme x0, int x1);
std::string* CasADi__getSchemeEntryEnumName(CasADi::InputOutputScheme x0, int x1){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getSchemeEntryEnumName(x0_, x1_) );
}


// ================== function "CasADi::getSchemeEntryEnum" ===============
// cppName: "CasADi::getSchemeEntryEnum"
// cWrapperName: "CasADi__getSchemeEntryEnum"
// protoArgs: "(CasADi::InputOutputScheme x0, std::string* x1)"
// params: [CasadiEnum InputOutputScheme,ConstRef StdString]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__getSchemeEntryEnum(CasADi::InputOutputScheme x0, std::string* x1)"
// call: "CasADi::getSchemeEntryEnum(x0_, x1_)"
extern "C"
    int CasADi__getSchemeEntryEnum(CasADi::InputOutputScheme x0, std::string* x1);
int CasADi__getSchemeEntryEnum(CasADi::InputOutputScheme x0, std::string* x1){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( CasADi::getSchemeEntryEnum(x0_, x1_) );
}


// ================== function "CasADi::getSchemeSize" ===============
// cppName: "CasADi::getSchemeSize"
// cWrapperName: "CasADi__getSchemeSize"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// params: [CasadiEnum InputOutputScheme]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__getSchemeSize(CasADi::InputOutputScheme x0)"
// call: "CasADi::getSchemeSize(x0_)"
extern "C"
    int CasADi__getSchemeSize(CasADi::InputOutputScheme x0);
int CasADi__getSchemeSize(CasADi::InputOutputScheme x0){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::getSchemeSize(x0_) );
}


// ================== function "CasADi::getSchemeName" ===============
// cppName: "CasADi::getSchemeName"
// cWrapperName: "CasADi__getSchemeName"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// params: [CasadiEnum InputOutputScheme]
// args: "(x0_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getSchemeName(CasADi::InputOutputScheme x0)"
// call: "CasADi::getSchemeName(x0_)"
extern "C"
    std::string* CasADi__getSchemeName(CasADi::InputOutputScheme x0);
std::string* CasADi__getSchemeName(CasADi::InputOutputScheme x0){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getSchemeName(x0_) );
}


// ================== function "CasADi::getSchemeEntryNames" ===============
// cppName: "CasADi::getSchemeEntryNames"
// cWrapperName: "CasADi__getSchemeEntryNames"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// params: [CasadiEnum InputOutputScheme]
// args: "(x0_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getSchemeEntryNames(CasADi::InputOutputScheme x0)"
// call: "CasADi::getSchemeEntryNames(x0_)"
extern "C"
    std::string* CasADi__getSchemeEntryNames(CasADi::InputOutputScheme x0);
std::string* CasADi__getSchemeEntryNames(CasADi::InputOutputScheme x0){
    CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getSchemeEntryNames(x0_) );
}


// ================== function "CasADi::complement" ===============
// cppName: "CasADi::complement"
// cWrapperName: "CasADi__complement"
// protoArgs: "(std::vector< int >* x0, int x1)"
// params: [ConstRef (StdVec CInt),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__complement(std::vector< int >* x0, int x1)"
// call: "CasADi::complement(x0_, x1_)"
extern "C"
    std::vector< int >* CasADi__complement(std::vector< int >* x0, int x1);
std::vector< int >* CasADi__complement(std::vector< int >* x0, int x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( CasADi::complement(x0_, x1_) );
}


// ================== function "CasADi::lookupvector" ===============
// cppName: "CasADi::lookupvector"
// cWrapperName: "CasADi__lookupvector"
// protoArgs: "(std::vector< int >* x0, int x1)"
// params: [ConstRef (StdVec CInt),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< int >*"
// proto: "std::vector< int >* CasADi__lookupvector(std::vector< int >* x0, int x1)"
// call: "CasADi::lookupvector(x0_, x1_)"
extern "C"
    std::vector< int >* CasADi__lookupvector(std::vector< int >* x0, int x1);
std::vector< int >* CasADi__lookupvector(std::vector< int >* x0, int x1){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< int >*, std::vector< int > >::wrapReturn( CasADi::lookupvector(x0_, x1_) );
}


// ================== function "CasADi::isIncreasing" ===============
// cppName: "CasADi::isIncreasing"
// cWrapperName: "CasADi__isIncreasing"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isIncreasing(std::vector< int >* x0)"
// call: "CasADi::isIncreasing(x0_)"
extern "C"
    int CasADi__isIncreasing(std::vector< int >* x0);
int CasADi__isIncreasing(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isIncreasing(x0_) );
}


// ================== function "CasADi::isDecreasing" ===============
// cppName: "CasADi::isDecreasing"
// cWrapperName: "CasADi__isDecreasing"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isDecreasing(std::vector< int >* x0)"
// call: "CasADi::isDecreasing(x0_)"
extern "C"
    int CasADi__isDecreasing(std::vector< int >* x0);
int CasADi__isDecreasing(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isDecreasing(x0_) );
}


// ================== function "CasADi::isNonIncreasing" ===============
// cppName: "CasADi::isNonIncreasing"
// cWrapperName: "CasADi__isNonIncreasing"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isNonIncreasing(std::vector< int >* x0)"
// call: "CasADi::isNonIncreasing(x0_)"
extern "C"
    int CasADi__isNonIncreasing(std::vector< int >* x0);
int CasADi__isNonIncreasing(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isNonIncreasing(x0_) );
}


// ================== function "CasADi::isNonDecreasing" ===============
// cppName: "CasADi::isNonDecreasing"
// cWrapperName: "CasADi__isNonDecreasing"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isNonDecreasing(std::vector< int >* x0)"
// call: "CasADi::isNonDecreasing(x0_)"
extern "C"
    int CasADi__isNonDecreasing(std::vector< int >* x0);
int CasADi__isNonDecreasing(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isNonDecreasing(x0_) );
}


// ================== function "CasADi::isMonotone" ===============
// cppName: "CasADi::isMonotone"
// cWrapperName: "CasADi__isMonotone"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isMonotone(std::vector< int >* x0)"
// call: "CasADi::isMonotone(x0_)"
extern "C"
    int CasADi__isMonotone(std::vector< int >* x0);
int CasADi__isMonotone(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isMonotone(x0_) );
}


// ================== function "CasADi::isStrictlyMonotone" ===============
// cppName: "CasADi::isStrictlyMonotone"
// cWrapperName: "CasADi__isStrictlyMonotone"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isStrictlyMonotone(std::vector< int >* x0)"
// call: "CasADi::isStrictlyMonotone(x0_)"
extern "C"
    int CasADi__isStrictlyMonotone(std::vector< int >* x0);
int CasADi__isStrictlyMonotone(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isStrictlyMonotone(x0_) );
}


// ================== function "CasADi::isRegular" ===============
// cppName: "CasADi::isRegular"
// cWrapperName: "CasADi__isRegular"
// protoArgs: "(std::vector< int >* x0)"
// params: [ConstRef (StdVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isRegular(std::vector< int >* x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    int CasADi__isRegular(std::vector< int >* x0);
int CasADi__isRegular(std::vector< int >* x0){
    std::vector< int > x0_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::isIncreasing'" ===============
// cppName: "CasADi::isIncreasing'"
// cWrapperName: "CasADi__isIncreasing_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isIncreasing_TIC(std::vector< double >* x0)"
// call: "CasADi::isIncreasing(x0_)"
extern "C"
    int CasADi__isIncreasing_TIC(std::vector< double >* x0);
int CasADi__isIncreasing_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isIncreasing(x0_) );
}


// ================== function "CasADi::isDecreasing'" ===============
// cppName: "CasADi::isDecreasing'"
// cWrapperName: "CasADi__isDecreasing_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isDecreasing_TIC(std::vector< double >* x0)"
// call: "CasADi::isDecreasing(x0_)"
extern "C"
    int CasADi__isDecreasing_TIC(std::vector< double >* x0);
int CasADi__isDecreasing_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isDecreasing(x0_) );
}


// ================== function "CasADi::isNonIncreasing'" ===============
// cppName: "CasADi::isNonIncreasing'"
// cWrapperName: "CasADi__isNonIncreasing_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isNonIncreasing_TIC(std::vector< double >* x0)"
// call: "CasADi::isNonIncreasing(x0_)"
extern "C"
    int CasADi__isNonIncreasing_TIC(std::vector< double >* x0);
int CasADi__isNonIncreasing_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isNonIncreasing(x0_) );
}


// ================== function "CasADi::isNonDecreasing'" ===============
// cppName: "CasADi::isNonDecreasing'"
// cWrapperName: "CasADi__isNonDecreasing_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isNonDecreasing_TIC(std::vector< double >* x0)"
// call: "CasADi::isNonDecreasing(x0_)"
extern "C"
    int CasADi__isNonDecreasing_TIC(std::vector< double >* x0);
int CasADi__isNonDecreasing_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isNonDecreasing(x0_) );
}


// ================== function "CasADi::isMonotone'" ===============
// cppName: "CasADi::isMonotone'"
// cWrapperName: "CasADi__isMonotone_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isMonotone_TIC(std::vector< double >* x0)"
// call: "CasADi::isMonotone(x0_)"
extern "C"
    int CasADi__isMonotone_TIC(std::vector< double >* x0);
int CasADi__isMonotone_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isMonotone(x0_) );
}


// ================== function "CasADi::isStrictlyMonotone'" ===============
// cppName: "CasADi::isStrictlyMonotone'"
// cWrapperName: "CasADi__isStrictlyMonotone_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isStrictlyMonotone_TIC(std::vector< double >* x0)"
// call: "CasADi::isStrictlyMonotone(x0_)"
extern "C"
    int CasADi__isStrictlyMonotone_TIC(std::vector< double >* x0);
int CasADi__isStrictlyMonotone_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isStrictlyMonotone(x0_) );
}


// ================== function "CasADi::isRegular'" ===============
// cppName: "CasADi::isRegular'"
// cWrapperName: "CasADi__isRegular_TIC"
// protoArgs: "(std::vector< double >* x0)"
// params: [ConstRef (StdVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isRegular_TIC(std::vector< double >* x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    int CasADi__isRegular_TIC(std::vector< double >* x0);
int CasADi__isRegular_TIC(std::vector< double >* x0){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::hash_combine" ===============
// cppName: "CasADi::hash_combine"
// cWrapperName: "CasADi__hash_combine"
// protoArgs: "(size_t* x0, std::vector< int >* x1)"
// params: [Ref CSize,ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__hash_combine(size_t* x0, std::vector< int >* x1)"
// call: "CasADi::hash_combine(x0_, x1_)"
extern "C"
    void CasADi__hash_combine(size_t* x0, std::vector< int >* x1);
void CasADi__hash_combine(size_t* x0, std::vector< int >* x1){
    size_t& x0_ = Marshaling<size_t&,size_t*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    CasADi::hash_combine(x0_, x1_);
}


// ================== function "CasADi::hash_sparsity" ===============
// cppName: "CasADi::hash_sparsity"
// cWrapperName: "CasADi__hash_sparsity"
// protoArgs: "(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// params: [CInt,CInt,ConstRef (StdVec CInt),ConstRef (StdVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "size_t"
// proto: "size_t CasADi__hash_sparsity(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3)"
// call: "CasADi::hash_sparsity(x0_, x1_, x2_, x3_)"
extern "C"
    size_t CasADi__hash_sparsity(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3);
size_t CasADi__hash_sparsity(int x0, int x1, std::vector< int >* x2, std::vector< int >* x3){
    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);

    return WrapReturn< size_t, size_t >::wrapReturn( CasADi::hash_sparsity(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::transpose" ===============
// cppName: "CasADi::transpose"
// cWrapperName: "CasADi__transpose"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__transpose(CasADi::Matrix< int >* x0)"
// call: "CasADi::transpose(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__transpose(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__transpose(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::transpose(x0_) );
}


// ================== function "CasADi::mul" ===============
// cppName: "CasADi::mul"
// cWrapperName: "CasADi__mul"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Sparsity* x2)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__mul(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Sparsity* x2)"
// call: "CasADi::mul(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__mul(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Sparsity* x2);
CasADi::Matrix< int >* CasADi__mul(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Sparsity* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Sparsity const & x2_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::mul(x0_, x1_, x2_) );
}


// ================== function "CasADi::mul'" ===============
// cppName: "CasADi::mul'"
// cWrapperName: "CasADi__mul_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__mul_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__mul_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__mul_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::mul(x0_, x1_) );
}


// ================== function "CasADi::mul''" ===============
// cppName: "CasADi::mul''"
// cWrapperName: "CasADi__mul_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< int >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass IMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__mul_TIC_TIC(std::vector< CasADi::Matrix< int >* >* x0)"
// call: "CasADi::mul(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__mul_TIC_TIC(std::vector< CasADi::Matrix< int >* >* x0);
CasADi::Matrix< int >* CasADi__mul_TIC_TIC(std::vector< CasADi::Matrix< int >* >* x0){
    std::vector< CasADi::Matrix< int > > x0_ = Marshaling<std::vector< CasADi::Matrix< int > >,std::vector< CasADi::Matrix< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::mul(x0_) );
}


// ================== function "CasADi::det" ===============
// cppName: "CasADi::det"
// cWrapperName: "CasADi__det"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__det(CasADi::Matrix< int >* x0)"
// call: "CasADi::det(x0_)"
extern "C"
    int CasADi__det(CasADi::Matrix< int >* x0);
int CasADi__det(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::det(x0_) );
}


// ================== function "CasADi::getMinor" ===============
// cppName: "CasADi::getMinor"
// cWrapperName: "CasADi__getMinor"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass IMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "int"
// proto: "int CasADi__getMinor(CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "CasADi::getMinor(x0_, x1_, x2_)"
extern "C"
    int CasADi__getMinor(CasADi::Matrix< int >* x0, int x1, int x2);
int CasADi__getMinor(CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< int, int >::wrapReturn( CasADi::getMinor(x0_, x1_, x2_) );
}


// ================== function "CasADi::cofactor" ===============
// cppName: "CasADi::cofactor"
// cWrapperName: "CasADi__cofactor"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass IMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "int"
// proto: "int CasADi__cofactor(CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "CasADi::cofactor(x0_, x1_, x2_)"
extern "C"
    int CasADi__cofactor(CasADi::Matrix< int >* x0, int x1, int x2);
int CasADi__cofactor(CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< int, int >::wrapReturn( CasADi::cofactor(x0_, x1_, x2_) );
}


// ================== function "CasADi::adj" ===============
// cppName: "CasADi::adj"
// cWrapperName: "CasADi__adj"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__adj(CasADi::Matrix< int >* x0)"
// call: "CasADi::adj(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__adj(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__adj(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::adj(x0_) );
}


// ================== function "CasADi::inv" ===============
// cppName: "CasADi::inv"
// cWrapperName: "CasADi__inv"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__inv(CasADi::Matrix< int >* x0)"
// call: "CasADi::inv(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__inv(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__inv(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::inv(x0_) );
}


// ================== function "CasADi::reshape" ===============
// cppName: "CasADi::reshape"
// cWrapperName: "CasADi__reshape"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass IMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__reshape(CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "CasADi::reshape(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__reshape(CasADi::Matrix< int >* x0, int x1, int x2);
CasADi::Matrix< int >* CasADi__reshape(CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::reshape'" ===============
// cppName: "CasADi::reshape'"
// cWrapperName: "CasADi__reshape_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__reshape_TIC(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__reshape_TIC(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__reshape_TIC(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec" ===============
// cppName: "CasADi::vec"
// cWrapperName: "CasADi__vec"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__vec(CasADi::Matrix< int >* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__vec(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__vec(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::vec(x0_) );
}


// ================== function "CasADi::vecNZ" ===============
// cppName: "CasADi::vecNZ"
// cWrapperName: "CasADi__vecNZ"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__vecNZ(CasADi::Matrix< int >* x0)"
// call: "CasADi::vecNZ(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__vecNZ(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__vecNZ(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::blockcat" ===============
// cppName: "CasADi::blockcat"
// cWrapperName: "CasADi__blockcat"
// protoArgs: "(std::vector< std::vector< CasADi::Matrix< int >* >* >* x0)"
// params: [ConstRef (StdVec (StdVec (CasadiClass IMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__blockcat(std::vector< std::vector< CasADi::Matrix< int >* >* >* x0)"
// call: "CasADi::blockcat(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__blockcat(std::vector< std::vector< CasADi::Matrix< int >* >* >* x0);
CasADi::Matrix< int >* CasADi__blockcat(std::vector< std::vector< CasADi::Matrix< int >* >* >* x0){
    std::vector< std::vector< CasADi::Matrix< int > > > x0_ = Marshaling<std::vector< std::vector< CasADi::Matrix< int > > >,std::vector< std::vector< CasADi::Matrix< int >* >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::blockcat(x0_) );
}


// ================== function "CasADi::blocksplit" ===============
// cppName: "CasADi::blocksplit"
// cWrapperName: "CasADi__blocksplit"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (StdVec CInt),ConstRef (StdVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< int >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< 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);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< int >* >* >*, std::vector< std::vector< CasADi::Matrix< int > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit'" ===============
// cppName: "CasADi::blocksplit'"
// cWrapperName: "CasADi__blocksplit_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass IMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< int >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC(CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC(CasADi::Matrix< int >* x0, int x1, int x2);
std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC(CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< int >* >* >*, std::vector< std::vector< CasADi::Matrix< int > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit''" ===============
// cppName: "CasADi::blocksplit''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1)"
// params: [ConstRef (CasadiClass IMatrix),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< int >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC_TIC(CasADi::Matrix< int >* x0, int x1)"
// call: "CasADi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC_TIC(CasADi::Matrix< int >* x0, int x1);
std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC_TIC(CasADi::Matrix< int >* x0, int x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< int >* >* >*, std::vector< std::vector< CasADi::Matrix< int > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_) );
}


// ================== function "CasADi::blocksplit'''" ===============
// cppName: "CasADi::blocksplit'''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< int >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC_TIC_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC_TIC_TIC(CasADi::Matrix< int >* x0);
std::vector< std::vector< CasADi::Matrix< int >* >* >* CasADi__blocksplit_TIC_TIC_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< int >* >* >*, std::vector< std::vector< CasADi::Matrix< int > > > >::wrapReturn( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::vertcat" ===============
// cppName: "CasADi::vertcat"
// cWrapperName: "CasADi__vertcat"
// protoArgs: "(std::vector< CasADi::Matrix< int >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass IMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__vertcat(std::vector< CasADi::Matrix< int >* >* x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__vertcat(std::vector< CasADi::Matrix< int >* >* x0);
CasADi::Matrix< int >* CasADi__vertcat(std::vector< CasADi::Matrix< int >* >* x0){
    std::vector< CasADi::Matrix< int > > x0_ = Marshaling<std::vector< CasADi::Matrix< int > >,std::vector< CasADi::Matrix< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::vertsplit" ===============
// cppName: "CasADi::vertsplit"
// cWrapperName: "CasADi__vertsplit"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit(CasADi::Matrix< int >* x0, std::vector< int >* x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit(CasADi::Matrix< int >* x0, std::vector< int >* x1);
std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit(CasADi::Matrix< int >* x0, std::vector< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit'" ===============
// cppName: "CasADi::vertsplit'"
// cWrapperName: "CasADi__vertsplit_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1)"
// params: [ConstRef (CasadiClass IMatrix),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit_TIC(CasADi::Matrix< int >* x0, int x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit_TIC(CasADi::Matrix< int >* x0, int x1);
std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit_TIC(CasADi::Matrix< int >* x0, int x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit''" ===============
// cppName: "CasADi::vertsplit''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit_TIC_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::vertsplit(x0_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit_TIC_TIC(CasADi::Matrix< int >* x0);
std::vector< CasADi::Matrix< int >* >* CasADi__vertsplit_TIC_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::vertsplit(x0_) );
}


// ================== function "CasADi::horzcat" ===============
// cppName: "CasADi::horzcat"
// cWrapperName: "CasADi__horzcat"
// protoArgs: "(std::vector< CasADi::Matrix< int >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass IMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__horzcat(std::vector< CasADi::Matrix< int >* >* x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__horzcat(std::vector< CasADi::Matrix< int >* >* x0);
CasADi::Matrix< int >* CasADi__horzcat(std::vector< CasADi::Matrix< int >* >* x0){
    std::vector< CasADi::Matrix< int > > x0_ = Marshaling<std::vector< CasADi::Matrix< int > >,std::vector< CasADi::Matrix< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::horzsplit" ===============
// cppName: "CasADi::horzsplit"
// cWrapperName: "CasADi__horzsplit"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit(CasADi::Matrix< int >* x0, std::vector< int >* x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit(CasADi::Matrix< int >* x0, std::vector< int >* x1);
std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit(CasADi::Matrix< int >* x0, std::vector< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit'" ===============
// cppName: "CasADi::horzsplit'"
// cWrapperName: "CasADi__horzsplit_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1)"
// params: [ConstRef (CasadiClass IMatrix),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit_TIC(CasADi::Matrix< int >* x0, int x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit_TIC(CasADi::Matrix< int >* x0, int x1);
std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit_TIC(CasADi::Matrix< int >* x0, int x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit''" ===============
// cppName: "CasADi::horzsplit''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< int >* >*"
// proto: "std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit_TIC_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::horzsplit(x0_)"
extern "C"
    std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit_TIC_TIC(CasADi::Matrix< int >* x0);
std::vector< CasADi::Matrix< int >* >* CasADi__horzsplit_TIC_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< int >* >*, std::vector< CasADi::Matrix< int > > >::wrapReturn( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::inner_prod" ===============
// cppName: "CasADi::inner_prod"
// cWrapperName: "CasADi__inner_prod"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__inner_prod(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::inner_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__inner_prod(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__inner_prod(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::inner_prod(x0_, x1_) );
}


// ================== function "CasADi::outer_prod" ===============
// cppName: "CasADi::outer_prod"
// cWrapperName: "CasADi__outer_prod"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__outer_prod(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::outer_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__outer_prod(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__outer_prod(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::outer_prod(x0_, x1_) );
}


// ================== function "CasADi::norm_1" ===============
// cppName: "CasADi::norm_1"
// cWrapperName: "CasADi__norm_1"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__norm_1(CasADi::Matrix< int >* x0)"
// call: "CasADi::norm_1(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__norm_1(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__norm_1(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::norm_1(x0_) );
}


// ================== function "CasADi::norm_2" ===============
// cppName: "CasADi::norm_2"
// cWrapperName: "CasADi__norm_2"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__norm_2(CasADi::Matrix< int >* x0)"
// call: "CasADi::norm_2(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__norm_2(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__norm_2(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::norm_2(x0_) );
}


// ================== function "CasADi::norm_inf" ===============
// cppName: "CasADi::norm_inf"
// cWrapperName: "CasADi__norm_inf"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__norm_inf(CasADi::Matrix< int >* x0)"
// call: "CasADi::norm_inf(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__norm_inf(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__norm_inf(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::norm_F" ===============
// cppName: "CasADi::norm_F"
// cWrapperName: "CasADi__norm_F"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__norm_F(CasADi::Matrix< int >* x0)"
// call: "CasADi::norm_F(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__norm_F(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__norm_F(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::norm_F(x0_) );
}


// ================== function "CasADi::qr" ===============
// cppName: "CasADi::qr"
// cWrapperName: "CasADi__qr"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// params: [ConstRef (CasadiClass IMatrix),Ref (CasadiClass IMatrix),Ref (CasadiClass IMatrix)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__qr(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2)"
// call: "CasADi::qr(x0_, x1_, x2_)"
extern "C"
    void CasADi__qr(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2);
void CasADi__qr(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1, CasADi::Matrix< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int >& x1_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x1);
    CasADi::Matrix< int >& x2_ = Marshaling<CasADi::Matrix< int >&,CasADi::Matrix< int >*>::marshal(x2);

    CasADi::qr(x0_, x1_, x2_);
}


// ================== function "CasADi::nullspace" ===============
// cppName: "CasADi::nullspace"
// cWrapperName: "CasADi__nullspace"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__nullspace(CasADi::Matrix< int >* x0)"
// call: "CasADi::nullspace(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__nullspace(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__nullspace(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::solve" ===============
// cppName: "CasADi::solve"
// cWrapperName: "CasADi__solve"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__solve(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::solve(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__solve(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__solve(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::solve(x0_, x1_) );
}


// ================== function "CasADi::pinv" ===============
// cppName: "CasADi::pinv"
// cWrapperName: "CasADi__pinv"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__pinv(CasADi::Matrix< int >* x0)"
// call: "CasADi::pinv(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__pinv(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__pinv(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::pinv(x0_) );
}


// ================== function "CasADi::repmat" ===============
// cppName: "CasADi::repmat"
// cWrapperName: "CasADi__repmat"
// protoArgs: "(CasADi::Matrix< int >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass IMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__repmat(CasADi::Matrix< int >* x0, int x1, int x2)"
// call: "CasADi::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__repmat(CasADi::Matrix< int >* x0, int x1, int x2);
CasADi::Matrix< int >* CasADi__repmat(CasADi::Matrix< int >* x0, int x1, int x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::unite" ===============
// cppName: "CasADi::unite"
// cWrapperName: "CasADi__unite"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__unite(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::unite(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__unite(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__unite(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::sumRows" ===============
// cppName: "CasADi::sumRows"
// cWrapperName: "CasADi__sumRows"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__sumRows(CasADi::Matrix< int >* x0)"
// call: "CasADi::sumRows(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__sumRows(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__sumRows(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumCols" ===============
// cppName: "CasADi::sumCols"
// cWrapperName: "CasADi__sumCols"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__sumCols(CasADi::Matrix< int >* x0)"
// call: "CasADi::sumCols(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__sumCols(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__sumCols(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumAll" ===============
// cppName: "CasADi::sumAll"
// cWrapperName: "CasADi__sumAll"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__sumAll(CasADi::Matrix< int >* x0)"
// call: "CasADi::sumAll(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__sumAll(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__sumAll(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::trace" ===============
// cppName: "CasADi::trace"
// cWrapperName: "CasADi__trace"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__trace(CasADi::Matrix< int >* x0)"
// call: "CasADi::trace(x0_)"
extern "C"
    int CasADi__trace(CasADi::Matrix< int >* x0);
int CasADi__trace(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::trace(x0_) );
}


// ================== function "CasADi::diag" ===============
// cppName: "CasADi::diag"
// cWrapperName: "CasADi__diag"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__diag(CasADi::Matrix< int >* x0)"
// call: "CasADi::diag(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__diag(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__diag(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag" ===============
// cppName: "CasADi::blkdiag"
// cWrapperName: "CasADi__blkdiag"
// protoArgs: "(std::vector< CasADi::Matrix< int >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass IMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__blkdiag(std::vector< CasADi::Matrix< int >* >* x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__blkdiag(std::vector< CasADi::Matrix< int >* >* x0);
CasADi::Matrix< int >* CasADi__blkdiag(std::vector< CasADi::Matrix< int >* >* x0){
    std::vector< CasADi::Matrix< int > > x0_ = Marshaling<std::vector< CasADi::Matrix< int > >,std::vector< CasADi::Matrix< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::polyval" ===============
// cppName: "CasADi::polyval"
// cWrapperName: "CasADi__polyval"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__polyval(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::polyval(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__polyval(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__polyval(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::polyval(x0_, x1_) );
}


// ================== function "CasADi::addMultiple" ===============
// cppName: "CasADi::addMultiple"
// cWrapperName: "CasADi__addMultiple"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (StdVec CInt),Ref (StdVec CInt),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3)"
// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__addMultiple(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3);
void CasADi__addMultiple(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2, int x3){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< 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);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    CasADi::addMultiple(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::addMultiple'" ===============
// cppName: "CasADi::addMultiple'"
// cWrapperName: "CasADi__addMultiple_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (StdVec CInt),Ref (StdVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void CasADi__addMultiple_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2);
void CasADi__addMultiple_TIC(CasADi::Matrix< int >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< 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::addMultiple(x0_, x1_, x2_);
}


// ================== function "CasADi::veccat" ===============
// cppName: "CasADi::veccat"
// cWrapperName: "CasADi__veccat"
// protoArgs: "(std::vector< CasADi::Matrix< int >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass IMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__veccat(std::vector< CasADi::Matrix< int >* >* x0)"
// call: "CasADi::veccat(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__veccat(std::vector< CasADi::Matrix< int >* >* x0);
CasADi::Matrix< int >* CasADi__veccat(std::vector< CasADi::Matrix< int >* >* x0){
    std::vector< CasADi::Matrix< int > > x0_ = Marshaling<std::vector< CasADi::Matrix< int > >,std::vector< CasADi::Matrix< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::veccat(x0_) );
}


// ================== function "CasADi::vecNZcat" ===============
// cppName: "CasADi::vecNZcat"
// cWrapperName: "CasADi__vecNZcat"
// protoArgs: "(std::vector< CasADi::Matrix< int >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass IMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__vecNZcat(std::vector< CasADi::Matrix< int >* >* x0)"
// call: "CasADi::vecNZcat(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__vecNZcat(std::vector< CasADi::Matrix< int >* >* x0);
CasADi::Matrix< int >* CasADi__vecNZcat(std::vector< CasADi::Matrix< int >* >* x0){
    std::vector< CasADi::Matrix< int > > x0_ = Marshaling<std::vector< CasADi::Matrix< int > >,std::vector< CasADi::Matrix< int >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::project" ===============
// cppName: "CasADi::project"
// cWrapperName: "CasADi__project"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__project(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::project(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__project(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< int >* CasADi__project(CasADi::Matrix< int >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::project(x0_, x1_) );
}


// ================== function "CasADi::sprank" ===============
// cppName: "CasADi::sprank"
// cWrapperName: "CasADi__sprank"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__sprank(CasADi::Matrix< int >* x0)"
// call: "CasADi::sprank(x0_)"
extern "C"
    int CasADi__sprank(CasADi::Matrix< int >* x0);
int CasADi__sprank(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::sprank(x0_) );
}


// ================== function "CasADi::kron" ===============
// cppName: "CasADi::kron"
// cWrapperName: "CasADi__kron"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__kron(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::kron(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__kron(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__kron(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::sparse" ===============
// cppName: "CasADi::sparse"
// cWrapperName: "CasADi__sparse"
// protoArgs: "(CasADi::Matrix< int >* x0, double x1)"
// params: [ConstRef (CasadiClass IMatrix),CDouble]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__sparse(CasADi::Matrix< int >* x0, double x1)"
// call: "CasADi::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__sparse(CasADi::Matrix< int >* x0, double x1);
CasADi::Matrix< int >* CasADi__sparse(CasADi::Matrix< int >* x0, double x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::sparse(x0_, x1_) );
}


// ================== function "CasADi::sparse'" ===============
// cppName: "CasADi::sparse'"
// cWrapperName: "CasADi__sparse_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__sparse_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::sparse(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__sparse_TIC(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__sparse_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::sparse(x0_) );
}


// ================== function "CasADi::dense" ===============
// cppName: "CasADi::dense"
// cWrapperName: "CasADi__dense"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__dense(CasADi::Matrix< int >* x0)"
// call: "CasADi::dense(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__dense(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__dense(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::dense(x0_) );
}


// ================== function "CasADi::transpose'" ===============
// cppName: "CasADi::transpose'"
// cWrapperName: "CasADi__transpose_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__transpose_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::transpose(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__transpose_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__transpose_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::transpose(x0_) );
}


// ================== function "CasADi::mul'''" ===============
// cppName: "CasADi::mul'''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Sparsity* x2)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Sparsity* x2)"
// call: "CasADi::mul(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Sparsity* x2);
CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Sparsity* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Sparsity const & x2_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::mul(x0_, x1_, x2_) );
}


// ================== function "CasADi::mul''''" ===============
// cppName: "CasADi::mul''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::mul(x0_, x1_) );
}


// ================== function "CasADi::mul'''''" ===============
// cppName: "CasADi::mul'''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< double >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< double >* >* x0)"
// call: "CasADi::mul(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< double >* >* x0);
CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::mul(x0_) );
}


// ================== function "CasADi::det'" ===============
// cppName: "CasADi::det'"
// cWrapperName: "CasADi__det_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double CasADi__det_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::det(x0_)"
extern "C"
    double CasADi__det_TIC(CasADi::Matrix< double >* x0);
double CasADi__det_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( CasADi::det(x0_) );
}


// ================== function "CasADi::getMinor'" ===============
// cppName: "CasADi::getMinor'"
// cWrapperName: "CasADi__getMinor_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass DMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "double"
// proto: "double CasADi__getMinor_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "CasADi::getMinor(x0_, x1_, x2_)"
extern "C"
    double CasADi__getMinor_TIC(CasADi::Matrix< double >* x0, int x1, int x2);
double CasADi__getMinor_TIC(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< double, double >::wrapReturn( CasADi::getMinor(x0_, x1_, x2_) );
}


// ================== function "CasADi::cofactor'" ===============
// cppName: "CasADi::cofactor'"
// cWrapperName: "CasADi__cofactor_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass DMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "double"
// proto: "double CasADi__cofactor_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "CasADi::cofactor(x0_, x1_, x2_)"
extern "C"
    double CasADi__cofactor_TIC(CasADi::Matrix< double >* x0, int x1, int x2);
double CasADi__cofactor_TIC(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< double, double >::wrapReturn( CasADi::cofactor(x0_, x1_, x2_) );
}


// ================== function "CasADi::adj'" ===============
// cppName: "CasADi::adj'"
// cWrapperName: "CasADi__adj_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__adj_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::adj(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__adj_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__adj_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::adj(x0_) );
}


// ================== function "CasADi::inv'" ===============
// cppName: "CasADi::inv'"
// cWrapperName: "CasADi__inv_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__inv_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::inv(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__inv_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__inv_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::inv(x0_) );
}


// ================== function "CasADi::reshape''" ===============
// cppName: "CasADi::reshape''"
// cWrapperName: "CasADi__reshape_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass DMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__reshape_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "CasADi::reshape(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__reshape_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__reshape_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::reshape'''" ===============
// cppName: "CasADi::reshape'''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec'" ===============
// cppName: "CasADi::vec'"
// cWrapperName: "CasADi__vec_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__vec_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__vec_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__vec_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::vec(x0_) );
}


// ================== function "CasADi::vecNZ'" ===============
// cppName: "CasADi::vecNZ'"
// cWrapperName: "CasADi__vecNZ_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__vecNZ_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::vecNZ(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__vecNZ_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__vecNZ_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::blockcat'" ===============
// cppName: "CasADi::blockcat'"
// cWrapperName: "CasADi__blockcat_TIC"
// protoArgs: "(std::vector< std::vector< CasADi::Matrix< double >* >* >* x0)"
// params: [ConstRef (StdVec (StdVec (CasadiClass DMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector< std::vector< CasADi::Matrix< double >* >* >* x0)"
// call: "CasADi::blockcat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector< std::vector< CasADi::Matrix< double >* >* >* x0);
CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector< std::vector< CasADi::Matrix< double >* >* >* x0){
    std::vector< std::vector< CasADi::Matrix< double > > > x0_ = Marshaling<std::vector< std::vector< CasADi::Matrix< double > > >,std::vector< std::vector< CasADi::Matrix< double >* >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::blockcat(x0_) );
}


// ================== function "CasADi::blocksplit''''" ===============
// cppName: "CasADi::blocksplit''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (StdVec CInt),ConstRef (StdVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< double >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::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);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< double >* >* >*, std::vector< std::vector< CasADi::Matrix< double > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit'''''" ===============
// cppName: "CasADi::blocksplit'''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass DMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< double >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2);
std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< double >* >* >*, std::vector< std::vector< CasADi::Matrix< double > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit''''''" ===============
// cppName: "CasADi::blocksplit''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"
// params: [ConstRef (CasadiClass DMatrix),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< double >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"
// call: "CasADi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);
std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< double >* >* >*, std::vector< std::vector< CasADi::Matrix< double > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_) );
}


// ================== function "CasADi::blocksplit'''''''" ===============
// cppName: "CasADi::blocksplit'''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< double >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
std::vector< std::vector< CasADi::Matrix< double >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< double >* >* >*, std::vector< std::vector< CasADi::Matrix< double > > > >::wrapReturn( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::vertcat'" ===============
// cppName: "CasADi::vertcat'"
// cWrapperName: "CasADi__vertcat_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< double >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector< CasADi::Matrix< double >* >* x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector< CasADi::Matrix< double >* >* x0);
CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::vertsplit'''" ===============
// cppName: "CasADi::vertsplit'''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1);
std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit''''" ===============
// cppName: "CasADi::vertsplit''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"
// params: [ConstRef (CasadiClass DMatrix),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);
std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit'''''" ===============
// cppName: "CasADi::vertsplit'''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::vertsplit(x0_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
std::vector< CasADi::Matrix< double >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::vertsplit(x0_) );
}


// ================== function "CasADi::horzcat'" ===============
// cppName: "CasADi::horzcat'"
// cWrapperName: "CasADi__horzcat_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< double >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector< CasADi::Matrix< double >* >* x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector< CasADi::Matrix< double >* >* x0);
CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::horzsplit'''" ===============
// cppName: "CasADi::horzsplit'''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1);
std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< int >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit''''" ===============
// cppName: "CasADi::horzsplit''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"
// params: [ConstRef (CasadiClass DMatrix),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);
std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit'''''" ===============
// cppName: "CasADi::horzsplit'''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< double >* >*"
// proto: "std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::horzsplit(x0_)"
extern "C"
    std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
std::vector< CasADi::Matrix< double >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< double >* >*, std::vector< CasADi::Matrix< double > > >::wrapReturn( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::inner_prod'" ===============
// cppName: "CasADi::inner_prod'"
// cWrapperName: "CasADi__inner_prod_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__inner_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::inner_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__inner_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__inner_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::inner_prod(x0_, x1_) );
}


// ================== function "CasADi::outer_prod'" ===============
// cppName: "CasADi::outer_prod'"
// cWrapperName: "CasADi__outer_prod_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__outer_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::outer_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__outer_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__outer_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::outer_prod(x0_, x1_) );
}


// ================== function "CasADi::norm_1'" ===============
// cppName: "CasADi::norm_1'"
// cWrapperName: "CasADi__norm_1_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__norm_1_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::norm_1(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__norm_1_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__norm_1_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::norm_1(x0_) );
}


// ================== function "CasADi::norm_2'" ===============
// cppName: "CasADi::norm_2'"
// cWrapperName: "CasADi__norm_2_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__norm_2_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::norm_2(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__norm_2_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__norm_2_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::norm_2(x0_) );
}


// ================== function "CasADi::norm_inf'" ===============
// cppName: "CasADi::norm_inf'"
// cWrapperName: "CasADi__norm_inf_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__norm_inf_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::norm_inf(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__norm_inf_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__norm_inf_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::norm_F'" ===============
// cppName: "CasADi::norm_F'"
// cWrapperName: "CasADi__norm_F_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__norm_F_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::norm_F(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__norm_F_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__norm_F_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::norm_F(x0_) );
}


// ================== function "CasADi::qr'" ===============
// cppName: "CasADi::qr'"
// cWrapperName: "CasADi__qr_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// params: [ConstRef (CasadiClass DMatrix),Ref (CasadiClass DMatrix),Ref (CasadiClass DMatrix)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__qr_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::qr(x0_, x1_, x2_)"
extern "C"
    void CasADi__qr_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);
void CasADi__qr_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double >& x1_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double >& x2_ = Marshaling<CasADi::Matrix< double >&,CasADi::Matrix< double >*>::marshal(x2);

    CasADi::qr(x0_, x1_, x2_);
}


// ================== function "CasADi::nullspace'" ===============
// cppName: "CasADi::nullspace'"
// cWrapperName: "CasADi__nullspace_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__nullspace_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::nullspace(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__nullspace_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__nullspace_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::solve'" ===============
// cppName: "CasADi::solve'"
// cWrapperName: "CasADi__solve_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__solve_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::solve(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__solve_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__solve_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::solve(x0_, x1_) );
}


// ================== function "CasADi::pinv'" ===============
// cppName: "CasADi::pinv'"
// cWrapperName: "CasADi__pinv_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__pinv_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::pinv(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__pinv_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__pinv_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::pinv(x0_) );
}


// ================== function "CasADi::repmat'" ===============
// cppName: "CasADi::repmat'"
// cWrapperName: "CasADi__repmat_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass DMatrix),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__repmat_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"
// call: "CasADi::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__repmat_TIC(CasADi::Matrix< double >* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__repmat_TIC(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::unite'" ===============
// cppName: "CasADi::unite'"
// cWrapperName: "CasADi__unite_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__unite_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::unite(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__unite_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__unite_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::sumRows'" ===============
// cppName: "CasADi::sumRows'"
// cWrapperName: "CasADi__sumRows_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__sumRows_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::sumRows(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__sumRows_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__sumRows_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumCols'" ===============
// cppName: "CasADi::sumCols'"
// cWrapperName: "CasADi__sumCols_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__sumCols_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::sumCols(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__sumCols_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__sumCols_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumAll'" ===============
// cppName: "CasADi::sumAll'"
// cWrapperName: "CasADi__sumAll_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__sumAll_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::sumAll(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__sumAll_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__sumAll_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::trace'" ===============
// cppName: "CasADi::trace'"
// cWrapperName: "CasADi__trace_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double CasADi__trace_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::trace(x0_)"
extern "C"
    double CasADi__trace_TIC(CasADi::Matrix< double >* x0);
double CasADi__trace_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( CasADi::trace(x0_) );
}


// ================== function "CasADi::diag'" ===============
// cppName: "CasADi::diag'"
// cWrapperName: "CasADi__diag_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__diag_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::diag(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__diag_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__diag_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag'" ===============
// cppName: "CasADi::blkdiag'"
// cWrapperName: "CasADi__blkdiag_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< double >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector< CasADi::Matrix< double >* >* x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector< CasADi::Matrix< double >* >* x0);
CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::polyval'" ===============
// cppName: "CasADi::polyval'"
// cWrapperName: "CasADi__polyval_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__polyval_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::polyval(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__polyval_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__polyval_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::polyval(x0_, x1_) );
}


// ================== function "CasADi::addMultiple''" ===============
// cppName: "CasADi::addMultiple''"
// cWrapperName: "CasADi__addMultiple_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2, int x3)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (StdVec CDouble),Ref (StdVec CDouble),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2, int x3)"
// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2, int x3);
void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2, int x3){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
    std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    CasADi::addMultiple(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::addMultiple'''" ===============
// cppName: "CasADi::addMultiple'''"
// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (StdVec CDouble),Ref (StdVec CDouble)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2)"
// call: "CasADi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2);
void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector< double >* x1, std::vector< double >* x2){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    std::vector< double > x1_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x1);
    std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

    CasADi::addMultiple(x0_, x1_, x2_);
}


// ================== function "CasADi::veccat'" ===============
// cppName: "CasADi::veccat'"
// cWrapperName: "CasADi__veccat_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< double >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector< CasADi::Matrix< double >* >* x0)"
// call: "CasADi::veccat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector< CasADi::Matrix< double >* >* x0);
CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::veccat(x0_) );
}


// ================== function "CasADi::vecNZcat'" ===============
// cppName: "CasADi::vecNZcat'"
// cWrapperName: "CasADi__vecNZcat_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< double >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector< CasADi::Matrix< double >* >* x0)"
// call: "CasADi::vecNZcat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector< CasADi::Matrix< double >* >* x0);
CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector< CasADi::Matrix< double >* >* x0){
    std::vector< CasADi::Matrix< double > > x0_ = Marshaling<std::vector< CasADi::Matrix< double > >,std::vector< CasADi::Matrix< double >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::project'" ===============
// cppName: "CasADi::project'"
// cWrapperName: "CasADi__project_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::project(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::project(x0_, x1_) );
}


// ================== function "CasADi::sprank'" ===============
// cppName: "CasADi::sprank'"
// cWrapperName: "CasADi__sprank_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__sprank_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::sprank(x0_)"
extern "C"
    int CasADi__sprank_TIC(CasADi::Matrix< double >* x0);
int CasADi__sprank_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::sprank(x0_) );
}


// ================== function "CasADi::kron'" ===============
// cppName: "CasADi::kron'"
// cWrapperName: "CasADi__kron_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__kron_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::kron(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__kron_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__kron_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::sparse''" ===============
// cppName: "CasADi::sparse''"
// cWrapperName: "CasADi__sparse_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, double x1)"
// params: [ConstRef (CasadiClass DMatrix),CDouble]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__sparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1)"
// call: "CasADi::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__sparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1);
CasADi::Matrix< double >* CasADi__sparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::sparse(x0_, x1_) );
}


// ================== function "CasADi::sparse'''" ===============
// cppName: "CasADi::sparse'''"
// cWrapperName: "CasADi__sparse_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__sparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::sparse(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__sparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__sparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::sparse(x0_) );
}


// ================== function "CasADi::dense'" ===============
// cppName: "CasADi::dense'"
// cWrapperName: "CasADi__dense_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__dense_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::dense(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__dense_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__dense_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::dense(x0_) );
}


// ================== function "CasADi::transpose''" ===============
// cppName: "CasADi::transpose''"
// cWrapperName: "CasADi__transpose_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__transpose_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::transpose(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__transpose_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__transpose_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::transpose(x0_) );
}


// ================== function "CasADi::mul''''''" ===============
// cppName: "CasADi::mul''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Sparsity* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Sparsity* x2)"
// call: "CasADi::mul(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Sparsity* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Sparsity* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Sparsity const & x2_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::mul(x0_, x1_, x2_) );
}


// ================== function "CasADi::mul'''''''" ===============
// cppName: "CasADi::mul'''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::mul(x0_, x1_) );
}


// ================== function "CasADi::mul''''''''" ===============
// cppName: "CasADi::mul''''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "CasADi::mul(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::mul(x0_) );
}


// ================== function "CasADi::det''" ===============
// cppName: "CasADi::det''"
// cWrapperName: "CasADi__det_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::det(x0_)"
extern "C"
    CasADi::SXElement* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::SXElement* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::det(x0_) );
}


// ================== function "CasADi::getMinor''" ===============
// cppName: "CasADi::getMinor''"
// cWrapperName: "CasADi__getMinor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass SX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "CasADi::getMinor(x0_, x1_, x2_)"
extern "C"
    CasADi::SXElement* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
CasADi::SXElement* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::getMinor(x0_, x1_, x2_) );
}


// ================== function "CasADi::cofactor''" ===============
// cppName: "CasADi::cofactor''"
// cWrapperName: "CasADi__cofactor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass SX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "CasADi::cofactor(x0_, x1_, x2_)"
extern "C"
    CasADi::SXElement* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
CasADi::SXElement* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::cofactor(x0_, x1_, x2_) );
}


// ================== function "CasADi::adj''" ===============
// cppName: "CasADi::adj''"
// cWrapperName: "CasADi__adj_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::adj(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::adj(x0_) );
}


// ================== function "CasADi::inv''" ===============
// cppName: "CasADi::inv''"
// cWrapperName: "CasADi__inv_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::inv(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::inv(x0_) );
}


// ================== function "CasADi::reshape''''" ===============
// cppName: "CasADi::reshape''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass SX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "CasADi::reshape(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::reshape'''''" ===============
// cppName: "CasADi::reshape'''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec''" ===============
// cppName: "CasADi::vec''"
// cWrapperName: "CasADi__vec_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::vec(x0_) );
}


// ================== function "CasADi::vecNZ''" ===============
// cppName: "CasADi::vecNZ''"
// cWrapperName: "CasADi__vecNZ_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::vecNZ(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::blockcat''" ===============
// cppName: "CasADi::blockcat''"
// cWrapperName: "CasADi__blockcat_TIC_TIC"
// protoArgs: "(std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x0)"
// params: [ConstRef (StdVec (StdVec (CasadiClass SX)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__blockcat_TIC_TIC(std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x0)"
// call: "CasADi::blockcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__blockcat_TIC_TIC(std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__blockcat_TIC_TIC(std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* x0){
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > x0_ = Marshaling<std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > >,std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::blockcat(x0_) );
}


// ================== function "CasADi::blocksplit''''''''" ===============
// cppName: "CasADi::blocksplit''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (StdVec CInt),ConstRef (StdVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::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);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit'''''''''" ===============
// cppName: "CasADi::blocksplit'''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass SX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit''''''''''" ===============
// cppName: "CasADi::blocksplit''''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// params: [ConstRef (CasadiClass SX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "CasADi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1);
std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > >::wrapReturn( CasADi::blocksplit(x0_, x1_) );
}


// ================== function "CasADi::blocksplit'''''''''''" ===============
// cppName: "CasADi::blocksplit'''''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*"
// proto: "std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< std::vector< CasADi::Matrix< CasADi::SXElement >* >* >*, std::vector< std::vector< CasADi::Matrix< CasADi::SXElement > > > >::wrapReturn( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::vertcat''" ===============
// cppName: "CasADi::vertcat''"
// cWrapperName: "CasADi__vertcat_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__vertcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__vertcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__vertcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::vertsplit''''''" ===============
// cppName: "CasADi::vertsplit''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit'''''''" ===============
// cppName: "CasADi::vertsplit'''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// params: [ConstRef (CasadiClass SX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit''''''''" ===============
// cppName: "CasADi::vertsplit''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::vertsplit(x0_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::vertsplit(x0_) );
}


// ================== function "CasADi::horzcat''" ===============
// cppName: "CasADi::horzcat''"
// cWrapperName: "CasADi__horzcat_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__horzcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__horzcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__horzcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::horzsplit''''''" ===============
// cppName: "CasADi::horzsplit''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< int >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit'''''''" ===============
// cppName: "CasADi::horzsplit'''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// params: [ConstRef (CasadiClass SX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit''''''''" ===============
// cppName: "CasADi::horzsplit''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::horzsplit(x0_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::inner_prod''" ===============
// cppName: "CasADi::inner_prod''"
// cWrapperName: "CasADi__inner_prod_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::inner_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::inner_prod(x0_, x1_) );
}


// ================== function "CasADi::outer_prod''" ===============
// cppName: "CasADi::outer_prod''"
// cWrapperName: "CasADi__outer_prod_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::outer_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::outer_prod(x0_, x1_) );
}


// ================== function "CasADi::norm_1''" ===============
// cppName: "CasADi::norm_1''"
// cWrapperName: "CasADi__norm_1_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::norm_1(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::norm_1(x0_) );
}


// ================== function "CasADi::norm_2''" ===============
// cppName: "CasADi::norm_2''"
// cWrapperName: "CasADi__norm_2_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::norm_2(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::norm_2(x0_) );
}


// ================== function "CasADi::norm_inf''" ===============
// cppName: "CasADi::norm_inf''"
// cWrapperName: "CasADi__norm_inf_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::norm_inf(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::norm_F''" ===============
// cppName: "CasADi::norm_F''"
// cWrapperName: "CasADi__norm_F_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::norm_F(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::norm_F(x0_) );
}


// ================== function "CasADi::qr''" ===============
// cppName: "CasADi::qr''"
// cWrapperName: "CasADi__qr_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),Ref (CasadiClass SX),Ref (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::qr(x0_, x1_, x2_)"
extern "C"
    void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement >& x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement >& x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    CasADi::qr(x0_, x1_, x2_);
}


// ================== function "CasADi::nullspace''" ===============
// cppName: "CasADi::nullspace''"
// cWrapperName: "CasADi__nullspace_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::nullspace(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::solve''" ===============
// cppName: "CasADi::solve''"
// cWrapperName: "CasADi__solve_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::solve(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::solve(x0_, x1_) );
}


// ================== function "CasADi::pinv''" ===============
// cppName: "CasADi::pinv''"
// cWrapperName: "CasADi__pinv_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::pinv(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::pinv(x0_) );
}


// ================== function "CasADi::repmat''" ===============
// cppName: "CasADi::repmat''"
// cWrapperName: "CasADi__repmat_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass SX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2)"
// call: "CasADi::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::unite''" ===============
// cppName: "CasADi::unite''"
// cWrapperName: "CasADi__unite_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::unite(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::sumRows''" ===============
// cppName: "CasADi::sumRows''"
// cWrapperName: "CasADi__sumRows_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::sumRows(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumCols''" ===============
// cppName: "CasADi::sumCols''"
// cWrapperName: "CasADi__sumCols_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::sumCols(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumAll''" ===============
// cppName: "CasADi::sumAll''"
// cWrapperName: "CasADi__sumAll_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::sumAll(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::trace''" ===============
// cppName: "CasADi::trace''"
// cWrapperName: "CasADi__trace_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::trace(x0_)"
extern "C"
    CasADi::SXElement* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::SXElement* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::trace(x0_) );
}


// ================== function "CasADi::diag''" ===============
// cppName: "CasADi::diag''"
// cWrapperName: "CasADi__diag_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::diag(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag''" ===============
// cppName: "CasADi::blkdiag''"
// cWrapperName: "CasADi__blkdiag_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__blkdiag_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__blkdiag_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__blkdiag_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::polyval''" ===============
// cppName: "CasADi::polyval''"
// cWrapperName: "CasADi__polyval_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::polyval(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::polyval(x0_, x1_) );
}


// ================== function "CasADi::addMultiple''''" ===============
// cppName: "CasADi::addMultiple''''"
// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, int x3)"
// params: [ConstRef (CasadiClass SX),ConstRef (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement)),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, int x3)"
// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, int x3);
void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, int x3){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    CasADi::addMultiple(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::addMultiple'''''" ===============
// cppName: "CasADi::addMultiple'''''"
// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// call: "CasADi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2);
void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);

    CasADi::addMultiple(x0_, x1_, x2_);
}


// ================== function "CasADi::veccat''" ===============
// cppName: "CasADi::veccat''"
// cWrapperName: "CasADi__veccat_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__veccat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "CasADi::veccat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__veccat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__veccat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::veccat(x0_) );
}


// ================== function "CasADi::vecNZcat''" ===============
// cppName: "CasADi::vecNZcat''"
// cWrapperName: "CasADi__vecNZcat_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// params: [ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__vecNZcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0)"
// call: "CasADi::vecNZcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__vecNZcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__vecNZcat_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::project''" ===============
// cppName: "CasADi::project''"
// cWrapperName: "CasADi__project_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1)"
// call: "CasADi::project(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Sparsity* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::project(x0_, x1_) );
}


// ================== function "CasADi::sprank''" ===============
// cppName: "CasADi::sprank''"
// cWrapperName: "CasADi__sprank_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::sprank(x0_)"
extern "C"
    int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::sprank(x0_) );
}


// ================== function "CasADi::kron''" ===============
// cppName: "CasADi::kron''"
// cWrapperName: "CasADi__kron_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::kron(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::sparse''''" ===============
// cppName: "CasADi::sparse''''"
// cWrapperName: "CasADi__sparse_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, double x1)"
// params: [ConstRef (CasadiClass SX),CDouble]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, double x1)"
// call: "CasADi::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, double x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, double x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::sparse(x0_, x1_) );
}


// ================== function "CasADi::sparse'''''" ===============
// cppName: "CasADi::sparse'''''"
// cWrapperName: "CasADi__sparse_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::sparse(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::sparse(x0_) );
}


// ================== function "CasADi::dense''" ===============
// cppName: "CasADi::dense''"
// cWrapperName: "CasADi__dense_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__dense_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::dense(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__dense_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__dense_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::dense(x0_) );
}


// ================== function "CasADi::cross" ===============
// cppName: "CasADi::cross"
// cWrapperName: "CasADi__cross"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1, int x2)"
// params: [ConstRef (CasadiClass GenIMatrix),ConstRef (CasadiClass GenIMatrix),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__cross(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1, int x2)"
// call: "CasADi::cross(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< int >* CasADi__cross(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1, int x2);
CasADi::Matrix< int >* CasADi__cross(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1, int x2){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::cross(x0_, x1_, x2_) );
}


// ================== function "CasADi::cross'" ===============
// cppName: "CasADi::cross'"
// cWrapperName: "CasADi__cross_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1)"
// params: [ConstRef (CasadiClass GenIMatrix),ConstRef (CasadiClass GenIMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__cross_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1)"
// call: "CasADi::cross(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__cross_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1);
CasADi::Matrix< int >* CasADi__cross_TIC(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::cross(x0_, x1_) );
}


// ================== function "CasADi::tril2symm" ===============
// cppName: "CasADi::tril2symm"
// cWrapperName: "CasADi__tril2symm"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// params: [ConstRef (CasadiClass GenIMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__tril2symm(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// call: "CasADi::tril2symm(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__tril2symm(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0);
CasADi::Matrix< int >* CasADi__tril2symm(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::tril2symm(x0_) );
}


// ================== function "CasADi::triu2symm" ===============
// cppName: "CasADi::triu2symm"
// cWrapperName: "CasADi__triu2symm"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// params: [ConstRef (CasadiClass GenIMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__triu2symm(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// call: "CasADi::triu2symm(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__triu2symm(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0);
CasADi::Matrix< int >* CasADi__triu2symm(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::triu2symm(x0_) );
}


// ================== function "CasADi::triu" ===============
// cppName: "CasADi::triu"
// cWrapperName: "CasADi__triu"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// params: [ConstRef (CasadiClass GenIMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__triu(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// call: "CasADi::triu(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__triu(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0);
CasADi::Matrix< int >* CasADi__triu(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::triu(x0_) );
}


// ================== function "CasADi::tril" ===============
// cppName: "CasADi::tril"
// cWrapperName: "CasADi__tril"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// params: [ConstRef (CasadiClass GenIMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__tril(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0)"
// call: "CasADi::tril(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__tril(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0);
CasADi::Matrix< int >* CasADi__tril(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::tril(x0_) );
}


// ================== function "CasADi::isEqual" ===============
// cppName: "CasADi::isEqual"
// cWrapperName: "CasADi__isEqual"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1)"
// params: [ConstRef (CasadiClass GenIMatrix),ConstRef (CasadiClass GenIMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isEqual(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    int CasADi__isEqual(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1);
int CasADi__isEqual(CasADi::GenericMatrix< CasADi::Matrix< int > >* x0, CasADi::GenericMatrix< CasADi::Matrix< int > >* x1){
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< int > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< int > > const &,CasADi::GenericMatrix< CasADi::Matrix< int > >*>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::cross''" ===============
// cppName: "CasADi::cross''"
// cWrapperName: "CasADi__cross_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2)"
// params: [ConstRef (CasadiClass GenDMatrix),ConstRef (CasadiClass GenDMatrix),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__cross_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2)"
// call: "CasADi::cross(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__cross_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2);
CasADi::Matrix< double >* CasADi__cross_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::cross(x0_, x1_, x2_) );
}


// ================== function "CasADi::cross'''" ===============
// cppName: "CasADi::cross'''"
// cWrapperName: "CasADi__cross_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1)"
// params: [ConstRef (CasadiClass GenDMatrix),ConstRef (CasadiClass GenDMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__cross_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1)"
// call: "CasADi::cross(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__cross_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1);
CasADi::Matrix< double >* CasADi__cross_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::cross(x0_, x1_) );
}


// ================== function "CasADi::tril2symm'" ===============
// cppName: "CasADi::tril2symm'"
// cWrapperName: "CasADi__tril2symm_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// params: [ConstRef (CasadiClass GenDMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__tril2symm_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// call: "CasADi::tril2symm(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__tril2symm_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0);
CasADi::Matrix< double >* CasADi__tril2symm_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::tril2symm(x0_) );
}


// ================== function "CasADi::triu2symm'" ===============
// cppName: "CasADi::triu2symm'"
// cWrapperName: "CasADi__triu2symm_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// params: [ConstRef (CasadiClass GenDMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__triu2symm_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// call: "CasADi::triu2symm(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__triu2symm_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0);
CasADi::Matrix< double >* CasADi__triu2symm_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::triu2symm(x0_) );
}


// ================== function "CasADi::triu'" ===============
// cppName: "CasADi::triu'"
// cWrapperName: "CasADi__triu_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// params: [ConstRef (CasadiClass GenDMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__triu_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// call: "CasADi::triu(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__triu_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0);
CasADi::Matrix< double >* CasADi__triu_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::triu(x0_) );
}


// ================== function "CasADi::tril'" ===============
// cppName: "CasADi::tril'"
// cWrapperName: "CasADi__tril_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// params: [ConstRef (CasadiClass GenDMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__tril_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0)"
// call: "CasADi::tril(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__tril_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0);
CasADi::Matrix< double >* CasADi__tril_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::tril(x0_) );
}


// ================== function "CasADi::isEqual'" ===============
// cppName: "CasADi::isEqual'"
// cWrapperName: "CasADi__isEqual_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1)"
// params: [ConstRef (CasadiClass GenDMatrix),ConstRef (CasadiClass GenDMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isEqual_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    int CasADi__isEqual_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1);
int CasADi__isEqual_TIC(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::cross''''" ===============
// cppName: "CasADi::cross''''"
// cWrapperName: "CasADi__cross_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2)"
// params: [ConstRef (CasadiClass GenSX),ConstRef (CasadiClass GenSX),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__cross_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2)"
// call: "CasADi::cross(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__cross_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__cross_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::cross(x0_, x1_, x2_) );
}


// ================== function "CasADi::cross'''''" ===============
// cppName: "CasADi::cross'''''"
// cWrapperName: "CasADi__cross_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1)"
// params: [ConstRef (CasadiClass GenSX),ConstRef (CasadiClass GenSX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__cross_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1)"
// call: "CasADi::cross(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__cross_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__cross_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::cross(x0_, x1_) );
}


// ================== function "CasADi::tril2symm''" ===============
// cppName: "CasADi::tril2symm''"
// cWrapperName: "CasADi__tril2symm_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// params: [ConstRef (CasadiClass GenSX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__tril2symm_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// call: "CasADi::tril2symm(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__tril2symm_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__tril2symm_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::tril2symm(x0_) );
}


// ================== function "CasADi::triu2symm''" ===============
// cppName: "CasADi::triu2symm''"
// cWrapperName: "CasADi__triu2symm_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// params: [ConstRef (CasadiClass GenSX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__triu2symm_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// call: "CasADi::triu2symm(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__triu2symm_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__triu2symm_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::triu2symm(x0_) );
}


// ================== function "CasADi::triu''" ===============
// cppName: "CasADi::triu''"
// cWrapperName: "CasADi__triu_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// params: [ConstRef (CasadiClass GenSX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__triu_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// call: "CasADi::triu(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__triu_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__triu_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::triu(x0_) );
}


// ================== function "CasADi::tril''" ===============
// cppName: "CasADi::tril''"
// cWrapperName: "CasADi__tril_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// params: [ConstRef (CasadiClass GenSX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__tril_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0)"
// call: "CasADi::tril(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__tril_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__tril_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::tril(x0_) );
}


// ================== function "CasADi::isEqual''" ===============
// cppName: "CasADi::isEqual''"
// cWrapperName: "CasADi__isEqual_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1)"
// params: [ConstRef (CasadiClass GenSX),ConstRef (CasadiClass GenSX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isEqual_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    int CasADi__isEqual_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1);
int CasADi__isEqual_TIC_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::cross''''''" ===============
// cppName: "CasADi::cross''''''"
// cWrapperName: "CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2)"
// params: [ConstRef (CasadiClass GenMX),ConstRef (CasadiClass GenMX),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2)"
// call: "CasADi::cross(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2);
CasADi::MX* CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::MX > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::cross(x0_, x1_, x2_) );
}


// ================== function "CasADi::cross'''''''" ===============
// cppName: "CasADi::cross'''''''"
// cWrapperName: "CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1)"
// params: [ConstRef (CasadiClass GenMX),ConstRef (CasadiClass GenMX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1)"
// call: "CasADi::cross(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1);
CasADi::MX* CasADi__cross_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::MX > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::cross(x0_, x1_) );
}


// ================== function "CasADi::tril2symm'''" ===============
// cppName: "CasADi::tril2symm'''"
// cWrapperName: "CasADi__tril2symm_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0)"
// params: [ConstRef (CasadiClass GenMX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__tril2symm_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0)"
// call: "CasADi::tril2symm(x0_)"
extern "C"
    CasADi::MX* CasADi__tril2symm_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0);
CasADi::MX* CasADi__tril2symm_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::tril2symm(x0_) );
}


// ================== function "CasADi::triu2symm'''" ===============
// cppName: "CasADi::triu2symm'''"
// cWrapperName: "CasADi__triu2symm_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0)"
// params: [ConstRef (CasadiClass GenMX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__triu2symm_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0)"
// call: "CasADi::triu2symm(x0_)"
extern "C"
    CasADi::MX* CasADi__triu2symm_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0);
CasADi::MX* CasADi__triu2symm_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::triu2symm(x0_) );
}


// ================== function "CasADi::triu'''" ===============
// cppName: "CasADi::triu'''"
// cWrapperName: "CasADi__triu_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0)"
// params: [ConstRef (CasadiClass GenMX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__triu_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0)"
// call: "CasADi::triu(x0_)"
extern "C"
    CasADi::MX* CasADi__triu_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0);
CasADi::MX* CasADi__triu_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::triu(x0_) );
}


// ================== function "CasADi::tril'''" ===============
// cppName: "CasADi::tril'''"
// cWrapperName: "CasADi__tril_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0)"
// params: [ConstRef (CasadiClass GenMX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__tril_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0)"
// call: "CasADi::tril(x0_)"
extern "C"
    CasADi::MX* CasADi__tril_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0);
CasADi::MX* CasADi__tril_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::tril(x0_) );
}


// ================== function "CasADi::isEqual'''" ===============
// cppName: "CasADi::isEqual'''"
// cWrapperName: "CasADi__isEqual_TIC_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1)"
// params: [ConstRef (CasadiClass GenMX),ConstRef (CasadiClass GenMX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__isEqual_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    int CasADi__isEqual_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1);
int CasADi__isEqual_TIC_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::MX > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::linspace" ===============
// cppName: "CasADi::linspace"
// cWrapperName: "CasADi__linspace"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2)"
// params: [ConstRef (CasadiClass GenDMatrix),ConstRef (CasadiClass GenDMatrix),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__linspace(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2)"
// call: "CasADi::linspace(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__linspace(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2);
CasADi::Matrix< double >* CasADi__linspace(CasADi::GenericMatrix< CasADi::Matrix< double > >* x0, CasADi::GenericMatrix< CasADi::Matrix< double > >* x1, int x2){
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< double > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< double > > const &,CasADi::GenericMatrix< CasADi::Matrix< double > >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::linspace(x0_, x1_, x2_) );
}


// ================== function "CasADi::linspace'" ===============
// cppName: "CasADi::linspace'"
// cWrapperName: "CasADi__linspace_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2)"
// params: [ConstRef (CasadiClass GenSX),ConstRef (CasadiClass GenSX),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__linspace_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2)"
// call: "CasADi::linspace(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__linspace_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__linspace_TIC(CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x0, CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >* x1, int x2){
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > > const &,CasADi::GenericMatrix< CasADi::Matrix< CasADi::SXElement > >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::linspace(x0_, x1_, x2_) );
}


// ================== function "CasADi::linspace''" ===============
// cppName: "CasADi::linspace''"
// cWrapperName: "CasADi__linspace_TIC_TIC"
// protoArgs: "(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2)"
// params: [ConstRef (CasadiClass GenMX),ConstRef (CasadiClass GenMX),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__linspace_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2)"
// call: "CasADi::linspace(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__linspace_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2);
CasADi::MX* CasADi__linspace_TIC_TIC(CasADi::GenericMatrix< CasADi::MX >* x0, CasADi::GenericMatrix< CasADi::MX >* x1, int x2){
    CasADi::GenericMatrix< CasADi::MX > const & x0_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x0);
    CasADi::GenericMatrix< CasADi::MX > const & x1_ = Marshaling<CasADi::GenericMatrix< CasADi::MX > const &,CasADi::GenericMatrix< CasADi::MX >*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::linspace(x0_, x1_, x2_) );
}


// ================== function "CasADi::logic_and" ===============
// cppName: "CasADi::logic_and"
// cWrapperName: "CasADi__logic_and"
// protoArgs: "(int const * x0, int const * x1)"
// params: [ConstRef CInt,ConstRef CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__logic_and(int const * x0, int const * x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    int CasADi__logic_and(int const * x0, int const * x1);
int CasADi__logic_and(int const * x0, int const * x1){
    int const & x0_ = Marshaling<int const &,int const *>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or" ===============
// cppName: "CasADi::logic_or"
// cWrapperName: "CasADi__logic_or"
// protoArgs: "(int const * x0, int const * x1)"
// params: [ConstRef CInt,ConstRef CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__logic_or(int const * x0, int const * x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    int CasADi__logic_or(int const * x0, int const * x1);
int CasADi__logic_or(int const * x0, int const * x1){
    int const & x0_ = Marshaling<int const &,int const *>::marshal(x0);
    int const & x1_ = Marshaling<int const &,int const *>::marshal(x1);

    return WrapReturn< int, int >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not" ===============
// cppName: "CasADi::logic_not"
// cWrapperName: "CasADi__logic_not"
// protoArgs: "(int const * x0)"
// params: [ConstRef CInt]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__logic_not(int const * x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    int CasADi__logic_not(int const * x0);
int CasADi__logic_not(int const * x0){
    int const & x0_ = Marshaling<int const &,int const *>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and'" ===============
// cppName: "CasADi::logic_and'"
// cWrapperName: "CasADi__logic_and_TIC"
// protoArgs: "(double const * x0, double const * x1)"
// params: [ConstRef CDouble,ConstRef CDouble]
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double CasADi__logic_and_TIC(double const * x0, double const * x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    double CasADi__logic_and_TIC(double const * x0, double const * x1);
double CasADi__logic_and_TIC(double const * x0, double const * x1){
    double const & x0_ = Marshaling<double const &,double const *>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    return WrapReturn< double, double >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or'" ===============
// cppName: "CasADi::logic_or'"
// cWrapperName: "CasADi__logic_or_TIC"
// protoArgs: "(double const * x0, double const * x1)"
// params: [ConstRef CDouble,ConstRef CDouble]
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double CasADi__logic_or_TIC(double const * x0, double const * x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    double CasADi__logic_or_TIC(double const * x0, double const * x1);
double CasADi__logic_or_TIC(double const * x0, double const * x1){
    double const & x0_ = Marshaling<double const &,double const *>::marshal(x0);
    double const & x1_ = Marshaling<double const &,double const *>::marshal(x1);

    return WrapReturn< double, double >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not'" ===============
// cppName: "CasADi::logic_not'"
// cWrapperName: "CasADi__logic_not_TIC"
// protoArgs: "(double const * x0)"
// params: [ConstRef CDouble]
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double CasADi__logic_not_TIC(double const * x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    double CasADi__logic_not_TIC(double const * x0);
double CasADi__logic_not_TIC(double const * x0){
    double const & x0_ = Marshaling<double const &,double const *>::marshal(x0);

    return WrapReturn< double, double >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and''" ===============
// cppName: "CasADi::logic_and''"
// cWrapperName: "CasADi__logic_and_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__logic_and_TIC_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__logic_and_TIC_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__logic_and_TIC_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or''" ===============
// cppName: "CasADi::logic_or''"
// cWrapperName: "CasADi__logic_or_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// params: [ConstRef (CasadiClass IMatrix),ConstRef (CasadiClass IMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__logic_or_TIC_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::Matrix< int >* CasADi__logic_or_TIC_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1);
CasADi::Matrix< int >* CasADi__logic_or_TIC_TIC(CasADi::Matrix< int >* x0, CasADi::Matrix< int >* x1){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);
    CasADi::Matrix< int > const & x1_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not''" ===============
// cppName: "CasADi::logic_not''"
// cWrapperName: "CasADi__logic_not_TIC_TIC"
// protoArgs: "(CasADi::Matrix< int >* x0)"
// params: [ConstRef (CasadiClass IMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< int >*"
// proto: "CasADi::Matrix< int >* CasADi__logic_not_TIC_TIC(CasADi::Matrix< int >* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::Matrix< int >* CasADi__logic_not_TIC_TIC(CasADi::Matrix< int >* x0);
CasADi::Matrix< int >* CasADi__logic_not_TIC_TIC(CasADi::Matrix< int >* x0){
    CasADi::Matrix< int > const & x0_ = Marshaling<CasADi::Matrix< int > const &,CasADi::Matrix< int >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< int >*, CasADi::Matrix< int > >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and'''" ===============
// cppName: "CasADi::logic_and'''"
// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__logic_and_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__logic_and_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__logic_and_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or'''" ===============
// cppName: "CasADi::logic_or'''"
// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (CasadiClass DMatrix),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__logic_or_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__logic_or_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__logic_or_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > const & x1_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not'''" ===============
// cppName: "CasADi::logic_not'''"
// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (CasadiClass DMatrix)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__logic_not_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__logic_not_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__logic_not_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > const & x0_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and''''" ===============
// cppName: "CasADi::logic_and''''"
// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or''''" ===============
// cppName: "CasADi::logic_or''''"
// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not''''" ===============
// cppName: "CasADi::logic_not''''"
// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and'''''" ===============
// cppName: "CasADi::logic_and'''''"
// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or'''''" ===============
// cppName: "CasADi::logic_or'''''"
// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not'''''" ===============
// cppName: "CasADi::logic_not'''''"
// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::MX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and''''''" ===============
// cppName: "CasADi::logic_and''''''"
// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXElement* x0, CasADi::SXElement* x1)"
// params: [ConstRef (CasadiClass SXElement),ConstRef (CasadiClass SXElement)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0, CasADi::SXElement* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0, CasADi::SXElement* x1);
CasADi::SXElement* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0, CasADi::SXElement* x1){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::logic_and(x0_, x1_) );
}


// ================== function "CasADi::logic_or''''''" ===============
// cppName: "CasADi::logic_or''''''"
// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXElement* x0, CasADi::SXElement* x1)"
// params: [ConstRef (CasadiClass SXElement),ConstRef (CasadiClass SXElement)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0, CasADi::SXElement* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::SXElement* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0, CasADi::SXElement* x1);
CasADi::SXElement* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0, CasADi::SXElement* x1){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    CasADi::SXElement const & x1_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x1);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::logic_or(x0_, x1_) );
}


// ================== function "CasADi::logic_not''''''" ===============
// cppName: "CasADi::logic_not''''''"
// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXElement* x0)"
// params: [ConstRef (CasadiClass SXElement)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SXElement*"
// proto: "CasADi::SXElement* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::SXElement* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0);
CasADi::SXElement* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SXElement* x0){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);

    return WrapReturn< CasADi::SXElement*, CasADi::SXElement >::wrapReturn( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::reshape''''''" ===============
// cppName: "CasADi::reshape''''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass Sparsity),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1, int x2)"
// call: "CasADi::reshape(x0_, x1_, x2_)"
extern "C"
    CasADi::Sparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1, int x2);
CasADi::Sparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1, int x2){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::transpose'''" ===============
// cppName: "CasADi::transpose'''"
// cWrapperName: "CasADi__transpose_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// params: [ConstRef (CasadiClass Sparsity)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__transpose_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::transpose(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__transpose_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__transpose_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::transpose(x0_) );
}


// ================== function "CasADi::vec'''" ===============
// cppName: "CasADi::vec'''"
// cWrapperName: "CasADi__vec_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// params: [ConstRef (CasadiClass Sparsity)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__vec_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__vec_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__vec_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::vec(x0_) );
}


// ================== function "CasADi::mul'''''''''" ===============
// cppName: "CasADi::mul'''''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass Sparsity),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::Sparsity* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::Sparsity* x1);
CasADi::Sparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, CasADi::Sparsity* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::mul(x0_, x1_) );
}


// ================== function "CasADi::vertcat'''" ===============
// cppName: "CasADi::vertcat'''"
// cWrapperName: "CasADi__vertcat_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// params: [ConstRef (StdVec (CasadiClass Sparsity))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0);
CasADi::Sparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::horzcat'''" ===============
// cppName: "CasADi::horzcat'''"
// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// params: [ConstRef (StdVec (CasadiClass Sparsity))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0);
CasADi::Sparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::blkdiag'''" ===============
// cppName: "CasADi::blkdiag'''"
// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0)"
// params: [ConstRef (StdVec (CasadiClass Sparsity))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0);
CasADi::Sparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector< CasADi::Sparsity* >* x0){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::horzsplit'''''''''" ===============
// cppName: "CasADi::horzsplit'''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass Sparsity),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Sparsity* >*"
// proto: "std::vector< CasADi::Sparsity* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Sparsity* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1);
std::vector< CasADi::Sparsity* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Sparsity* >*, std::vector< CasADi::Sparsity > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit'''''''''" ===============
// cppName: "CasADi::vertsplit'''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass Sparsity),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::Sparsity* >*"
// proto: "std::vector< CasADi::Sparsity* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::Sparsity* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1);
std::vector< CasADi::Sparsity* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, std::vector< int >* x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::Sparsity* >*, std::vector< CasADi::Sparsity > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::rank" ===============
// cppName: "CasADi::rank"
// cWrapperName: "CasADi__rank"
// protoArgs: "(CasADi::Sparsity* x0)"
// params: [ConstRef (CasadiClass Sparsity)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__rank(CasADi::Sparsity* x0)"
// call: "CasADi::rank(x0_)"
extern "C"
    int CasADi__rank(CasADi::Sparsity* x0);
int CasADi__rank(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::rank(x0_) );
}


// ================== function "CasADi::triu''''" ===============
// cppName: "CasADi::triu''''"
// cWrapperName: "CasADi__triu_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// params: [ConstRef (CasadiClass Sparsity),CBool]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__triu_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::triu(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__triu_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1);
CasADi::Sparsity* CasADi__triu_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::triu(x0_, x1_) );
}


// ================== function "CasADi::triu'''''" ===============
// cppName: "CasADi::triu'''''"
// cWrapperName: "CasADi__triu_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// params: [ConstRef (CasadiClass Sparsity)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__triu_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::triu(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__triu_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__triu_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::triu(x0_) );
}


// ================== function "CasADi::tril''''" ===============
// cppName: "CasADi::tril''''"
// cWrapperName: "CasADi__tril_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0, int x1)"
// params: [ConstRef (CasadiClass Sparsity),CBool]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__tril_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1)"
// call: "CasADi::tril(x0_, x1_)"
extern "C"
    CasADi::Sparsity* CasADi__tril_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1);
CasADi::Sparsity* CasADi__tril_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0, int x1){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,int>::marshal(x1);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::tril(x0_, x1_) );
}


// ================== function "CasADi::tril'''''" ===============
// cppName: "CasADi::tril'''''"
// cWrapperName: "CasADi__tril_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Sparsity* x0)"
// params: [ConstRef (CasadiClass Sparsity)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Sparsity*"
// proto: "CasADi::Sparsity* CasADi__tril_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0)"
// call: "CasADi::tril(x0_)"
extern "C"
    CasADi::Sparsity* CasADi__tril_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0);
CasADi::Sparsity* CasADi__tril_TIC_TIC_TIC_TIC_TIC(CasADi::Sparsity* x0){
    CasADi::Sparsity const & x0_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x0);

    return WrapReturn< CasADi::Sparsity*, CasADi::Sparsity >::wrapReturn( CasADi::tril(x0_) );
}


// ================== function "CasADi::expand" ===============
// cppName: "CasADi::expand"
// cWrapperName: "CasADi__expand"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),Ref (CasadiClass SX),Ref (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__expand(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::expand(x0_, x1_, x2_)"
extern "C"
    void CasADi__expand(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
void CasADi__expand(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement >& x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement >& x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    CasADi::expand(x0_, x1_, x2_);
}


// ================== function "CasADi::simplify" ===============
// cppName: "CasADi::simplify"
// cWrapperName: "CasADi__simplify"
// protoArgs: "(CasADi::SXElement* x0)"
// params: [Ref (CasadiClass SXElement)]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__simplify(CasADi::SXElement* x0)"
// call: "CasADi::simplify(x0_)"
extern "C"
    void CasADi__simplify(CasADi::SXElement* x0);
void CasADi__simplify(CasADi::SXElement* x0){
    CasADi::SXElement& x0_ = Marshaling<CasADi::SXElement&,CasADi::SXElement*>::marshal(x0);

    CasADi::simplify(x0_);
}


// ================== function "CasADi::pw_const" ===============
// cppName: "CasADi::pw_const"
// cWrapperName: "CasADi__pw_const"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__pw_const(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::pw_const(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__pw_const(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__pw_const(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::pw_const(x0_, x1_, x2_) );
}


// ================== function "CasADi::pw_lin" ===============
// cppName: "CasADi::pw_lin"
// cWrapperName: "CasADi__pw_lin"
// protoArgs: "(CasADi::SXElement* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SXElement),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__pw_lin(CasADi::SXElement* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::pw_lin(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__pw_lin(CasADi::SXElement* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__pw_lin(CasADi::SXElement* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::pw_lin(x0_, x1_, x2_) );
}


// ================== function "CasADi::if_else" ===============
// cppName: "CasADi::if_else"
// cWrapperName: "CasADi__if_else"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__if_else(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::if_else(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__if_else(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__if_else(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::if_else(x0_, x1_, x2_) );
}


// ================== function "CasADi::heaviside" ===============
// cppName: "CasADi::heaviside"
// cWrapperName: "CasADi__heaviside"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__heaviside(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::heaviside(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__heaviside(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__heaviside(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::heaviside(x0_) );
}


// ================== function "CasADi::rectangle" ===============
// cppName: "CasADi::rectangle"
// cWrapperName: "CasADi__rectangle"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__rectangle(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::rectangle(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__rectangle(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__rectangle(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::rectangle(x0_) );
}


// ================== function "CasADi::triangle" ===============
// cppName: "CasADi::triangle"
// cWrapperName: "CasADi__triangle"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__triangle(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::triangle(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__triangle(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__triangle(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::triangle(x0_) );
}


// ================== function "CasADi::ramp" ===============
// cppName: "CasADi::ramp"
// cWrapperName: "CasADi__ramp"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__ramp(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::ramp(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__ramp(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__ramp(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::ramp(x0_) );
}


// ================== function "CasADi::gauss_quadrature" ===============
// cppName: "CasADi::gauss_quadrature"
// cWrapperName: "CasADi__gauss_quadrature"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4, CasADi::Matrix< CasADi::SXElement >* x5)"
// params: [CasadiClass SX,ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),CInt,ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4, CasADi::Matrix< CasADi::SXElement >* x5)"
// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4, CasADi::Matrix< CasADi::SXElement >* x5);
CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4, CasADi::Matrix< CasADi::SXElement >* x5){
    CasADi::Matrix< CasADi::SXElement > x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    CasADi::Matrix< CasADi::SXElement > const & x3_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);
    CasADi::Matrix< CasADi::SXElement > const & x5_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x5);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_) );
}


// ================== function "CasADi::gauss_quadrature'" ===============
// cppName: "CasADi::gauss_quadrature'"
// cWrapperName: "CasADi__gauss_quadrature_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4)"
// params: [CasadiClass SX,ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),CInt]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4)"
// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4);
CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3, int x4){
    CasADi::Matrix< CasADi::SXElement > x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    CasADi::Matrix< CasADi::SXElement > const & x3_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_) );
}


// ================== function "CasADi::gauss_quadrature''" ===============
// cppName: "CasADi::gauss_quadrature''"
// cWrapperName: "CasADi__gauss_quadrature_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3)"
// params: [CasadiClass SX,ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3)"
// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3){
    CasADi::Matrix< CasADi::SXElement > x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    CasADi::Matrix< CasADi::SXElement > const & x3_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x3);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::simplify'" ===============
// cppName: "CasADi::simplify'"
// cWrapperName: "CasADi__simplify_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [Ref (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::simplify(x0_)"
extern "C"
    void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement >& x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    CasADi::simplify(x0_);
}


// ================== function "CasADi::compress" ===============
// cppName: "CasADi::compress"
// cWrapperName: "CasADi__compress"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// params: [Ref (CasadiClass SX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__compress(CasADi::Matrix< CasADi::SXElement >* x0, int x1)"
// call: "CasADi::compress(x0_, x1_)"
extern "C"
    void CasADi__compress(CasADi::Matrix< CasADi::SXElement >* x0, int x1);
void CasADi__compress(CasADi::Matrix< CasADi::SXElement >* x0, int x1){
    CasADi::Matrix< CasADi::SXElement >& x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    CasADi::compress(x0_, x1_);
}


// ================== function "CasADi::compress'" ===============
// cppName: "CasADi::compress'"
// cWrapperName: "CasADi__compress_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [Ref (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__compress_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::compress(x0_)"
extern "C"
    void CasADi__compress_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__compress_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement >& x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    CasADi::compress(x0_);
}


// ================== function "CasADi::substitute" ===============
// cppName: "CasADi::substitute"
// cWrapperName: "CasADi__substitute"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__substitute(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::substitute(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__substitute(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__substitute(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::substitute'" ===============
// cppName: "CasADi::substitute'"
// cWrapperName: "CasADi__substitute_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2)"
// params: [ConstRef (StdVec (CasadiClass SX)),ConstRef (StdVec (CasadiClass SX)),ConstRef (StdVec (CasadiClass SX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< CasADi::Matrix< CasADi::SXElement >* >*"
// proto: "std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__substitute_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2)"
// call: "CasADi::substitute(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__substitute_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2);
std::vector< CasADi::Matrix< CasADi::SXElement >* >* CasADi__substitute_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x2_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x2);

    return WrapReturn< std::vector< CasADi::Matrix< CasADi::SXElement >* >*, std::vector< CasADi::Matrix< CasADi::SXElement > > >::wrapReturn( CasADi::substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::substituteInPlace" ===============
// cppName: "CasADi::substituteInPlace"
// cWrapperName: "CasADi__substituteInPlace"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, int x2)"
// params: [ConstRef (CasadiClass SX),Ref (CasadiClass SX),CBool]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, int x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, int x2);
void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, int x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement >& x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::substituteInPlace'" ===============
// cppName: "CasADi::substituteInPlace'"
// cWrapperName: "CasADi__substituteInPlace_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),Ref (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::substituteInPlace(x0_, x1_)"
extern "C"
    void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement >& x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    CasADi::substituteInPlace(x0_, x1_);
}


// ================== function "CasADi::substituteInPlace''" ===============
// cppName: "CasADi::substituteInPlace''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3)"
// params: [ConstRef (CasadiClass SX),Ref (CasadiClass SX),Ref (StdVec (CasadiClass SX)),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3);
void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement >& x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x2_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    CasADi::substituteInPlace(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::substituteInPlace'''" ===============
// cppName: "CasADi::substituteInPlace'''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2)"
// params: [ConstRef (CasadiClass SX),Ref (CasadiClass SX),Ref (StdVec (CasadiClass SX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2);
void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement >& x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x2_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x2);

    CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::substituteInPlace''''" ===============
// cppName: "CasADi::substituteInPlace''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3)"
// params: [ConstRef (StdVec (CasadiClass SX)),Ref (StdVec (CasadiClass SX)),Ref (StdVec (CasadiClass SX)),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2, int x3){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x2_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    CasADi::substituteInPlace(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::substituteInPlace'''''" ===============
// cppName: "CasADi::substituteInPlace'''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2)"
// params: [ConstRef (StdVec (CasadiClass SX)),Ref (StdVec (CasadiClass SX)),Ref (StdVec (CasadiClass SX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::Matrix< CasADi::SXElement >* >* x0, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x1, std::vector< CasADi::Matrix< CasADi::SXElement >* >* x2){
    std::vector< CasADi::Matrix< CasADi::SXElement > > x0_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x0);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x1_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x1);
    std::vector< CasADi::Matrix< CasADi::SXElement > > x2_ = Marshaling<std::vector< CasADi::Matrix< CasADi::SXElement > >,std::vector< CasADi::Matrix< CasADi::SXElement >* >*>::marshal(x2);

    CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::evalf" ===============
// cppName: "CasADi::evalf"
// cWrapperName: "CasADi__evalf"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::evalf(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::evalf(x0_) );
}


// ================== function "CasADi::evalf'" ===============
// cppName: "CasADi::evalf'"
// cWrapperName: "CasADi__evalf_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< double >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass DMatrix)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::evalf(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< double >* x2);
CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< double > const & x2_ = Marshaling<CasADi::Matrix< double > const &,CasADi::Matrix< double >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< double >*, CasADi::Matrix< double > >::wrapReturn( CasADi::evalf(x0_, x1_, x2_) );
}


// ================== function "CasADi::spy" ===============
// cppName: "CasADi::spy"
// cWrapperName: "CasADi__spy"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__spy(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::spy(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__spy(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__spy(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::spy(x0_) );
}


// ================== function "CasADi::dependsOn" ===============
// cppName: "CasADi::dependsOn"
// cWrapperName: "CasADi__dependsOn"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__dependsOn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::dependsOn(x0_, x1_)"
extern "C"
    int CasADi__dependsOn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
int CasADi__dependsOn(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( CasADi::dependsOn(x0_, x1_) );
}


// ================== function "CasADi::getSymbols" ===============
// cppName: "CasADi::getSymbols"
// cWrapperName: "CasADi__getSymbols"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::SXElement* >*"
// proto: "std::vector< CasADi::SXElement* >* CasADi__getSymbols(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::getSymbols(x0_)"
extern "C"
    std::vector< CasADi::SXElement* >* CasADi__getSymbols(CasADi::Matrix< CasADi::SXElement >* x0);
std::vector< CasADi::SXElement* >* CasADi__getSymbols(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::SXElement* >*, std::vector< CasADi::SXElement > >::wrapReturn( CasADi::getSymbols(x0_) );
}


// ================== function "CasADi::jacobian" ===============
// cppName: "CasADi::jacobian"
// cWrapperName: "CasADi__jacobian"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__jacobian(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::jacobian(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__jacobian(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__jacobian(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::jacobian(x0_, x1_) );
}


// ================== function "CasADi::gradient" ===============
// cppName: "CasADi::gradient"
// cWrapperName: "CasADi__gradient"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__gradient(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::gradient(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__gradient(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__gradient(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::gradient(x0_, x1_) );
}


// ================== function "CasADi::tangent" ===============
// cppName: "CasADi::tangent"
// cWrapperName: "CasADi__tangent"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__tangent(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::tangent(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__tangent(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__tangent(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::tangent(x0_, x1_) );
}


// ================== function "CasADi::hessian" ===============
// cppName: "CasADi::hessian"
// cWrapperName: "CasADi__hessian"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__hessian(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::hessian(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__hessian(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__hessian(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::hessian(x0_, x1_) );
}


// ================== function "CasADi::hessian'" ===============
// cppName: "CasADi::hessian'"
// cWrapperName: "CasADi__hessian_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),Ref (CasadiClass SX),Ref (CasadiClass SX)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3)"
// call: "CasADi::hessian(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3);
void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, CasADi::Matrix< CasADi::SXElement >* x3){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement >& x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    CasADi::Matrix< CasADi::SXElement >& x3_ = Marshaling<CasADi::Matrix< CasADi::SXElement >&,CasADi::Matrix< CasADi::SXElement >*>::marshal(x3);

    CasADi::hessian(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::jacobianTimesVector" ===============
// cppName: "CasADi::jacobianTimesVector"
// cWrapperName: "CasADi__jacobianTimesVector"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3)"
// call: "CasADi::jacobianTimesVector(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::jacobianTimesVector(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::jacobianTimesVector'" ===============
// cppName: "CasADi::jacobianTimesVector'"
// cWrapperName: "CasADi__jacobianTimesVector_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::jacobianTimesVector(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::jacobianTimesVector(x0_, x1_, x2_) );
}


// ================== function "CasADi::taylor" ===============
// cppName: "CasADi::taylor"
// cWrapperName: "CasADi__taylor"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),CInt]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__taylor(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3)"
// call: "CasADi::taylor(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__taylor(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__taylor(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::taylor(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::taylor'" ===============
// cppName: "CasADi::taylor'"
// cWrapperName: "CasADi__taylor_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::taylor(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::taylor(x0_, x1_, x2_) );
}


// ================== function "CasADi::taylor''" ===============
// cppName: "CasADi::taylor''"
// cWrapperName: "CasADi__taylor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::taylor(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::taylor(x0_, x1_) );
}


// ================== function "CasADi::mtaylor" ===============
// cppName: "CasADi::mtaylor"
// cWrapperName: "CasADi__mtaylor"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),CInt]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3)"
// call: "CasADi::mtaylor(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3);
CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::mtaylor(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::mtaylor'" ===============
// cppName: "CasADi::mtaylor'"
// cWrapperName: "CasADi__mtaylor_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2)"
// call: "CasADi::mtaylor(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2);
CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::mtaylor(x0_, x1_, x2_) );
}


// ================== function "CasADi::mtaylor''" ===============
// cppName: "CasADi::mtaylor''"
// cWrapperName: "CasADi__mtaylor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3, std::vector< int >* x4)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),ConstRef (CasadiClass SX),CInt,ConstRef (StdVec CInt)]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3, std::vector< int >* x4)"
// call: "CasADi::mtaylor(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3, std::vector< int >* x4);
CasADi::Matrix< CasADi::SXElement >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1, CasADi::Matrix< CasADi::SXElement >* x2, int x3, std::vector< int >* x4){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);
    CasADi::Matrix< CasADi::SXElement > const & x2_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);
    std::vector< int > x4_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x4);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::mtaylor(x0_, x1_, x2_, x3_, x4_) );
}


// ================== function "CasADi::countNodes" ===============
// cppName: "CasADi::countNodes"
// cWrapperName: "CasADi__countNodes"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__countNodes(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::countNodes(x0_)"
extern "C"
    int CasADi__countNodes(CasADi::Matrix< CasADi::SXElement >* x0);
int CasADi__countNodes(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::countNodes(x0_) );
}


// ================== function "CasADi::getOperatorRepresentation" ===============
// cppName: "CasADi::getOperatorRepresentation"
// cWrapperName: "CasADi__getOperatorRepresentation"
// protoArgs: "(CasADi::SXElement* x0, std::vector< std::string* >* x1)"
// params: [ConstRef (CasadiClass SXElement),ConstRef (StdVec StdString)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getOperatorRepresentation(CasADi::SXElement* x0, std::vector< std::string* >* x1)"
// call: "CasADi::getOperatorRepresentation(x0_, x1_)"
extern "C"
    std::string* CasADi__getOperatorRepresentation(CasADi::SXElement* x0, std::vector< std::string* >* x1);
std::string* CasADi__getOperatorRepresentation(CasADi::SXElement* x0, std::vector< std::string* >* x1){
    CasADi::SXElement const & x0_ = Marshaling<CasADi::SXElement const &,CasADi::SXElement*>::marshal(x0);
    std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getOperatorRepresentation(x0_, x1_) );
}


// ================== function "CasADi::getFree" ===============
// cppName: "CasADi::getFree"
// cWrapperName: "CasADi__getFree"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__getFree(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::getFree(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__getFree(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__getFree(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::getFree(x0_) );
}


// ================== function "CasADi::extractShared" ===============
// cppName: "CasADi::extractShared"
// cWrapperName: "CasADi__extractShared"
// protoArgs: "(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3, std::string* x4)"
// params: [Ref (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement)),ConstRef StdString,ConstRef StdString]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3, std::string* x4)"
// call: "CasADi::extractShared(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    void CasADi__extractShared(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3, std::string* x4);
void CasADi__extractShared(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3, std::string* x4){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);

    CasADi::extractShared(x0_, x1_, x2_, x3_, x4_);
}


// ================== function "CasADi::extractShared'" ===============
// cppName: "CasADi::extractShared'"
// cWrapperName: "CasADi__extractShared_TIC"
// protoArgs: "(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3)"
// params: [Ref (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement)),ConstRef StdString]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3)"
// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__extractShared_TIC(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3);
void CasADi__extractShared_TIC(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2, std::string* x3){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);

    CasADi::extractShared(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::extractShared''" ===============
// cppName: "CasADi::extractShared''"
// cWrapperName: "CasADi__extractShared_TIC_TIC"
// protoArgs: "(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// params: [Ref (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement)),Ref (StdVec (CasadiClass SXElement))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC_TIC(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2)"
// call: "CasADi::extractShared(x0_, x1_, x2_)"
extern "C"
    void CasADi__extractShared_TIC_TIC(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2);
void CasADi__extractShared_TIC_TIC(std::vector< CasADi::SXElement* >* x0, std::vector< CasADi::SXElement* >* x1, std::vector< CasADi::SXElement* >* x2){
    std::vector< CasADi::SXElement > x0_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x0);
    std::vector< CasADi::SXElement > x1_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x1);
    std::vector< CasADi::SXElement > x2_ = Marshaling<std::vector< CasADi::SXElement >,std::vector< CasADi::SXElement* >*>::marshal(x2);

    CasADi::extractShared(x0_, x1_, x2_);
}


// ================== function "CasADi::printCompact'" ===============
// cppName: "CasADi::printCompact'"
// cWrapperName: "CasADi__printCompact_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::printCompact(x0_)"
extern "C"
    void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SXElement >* x0);
void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    CasADi::printCompact(x0_);
}


// ================== function "CasADi::poly_coeff" ===============
// cppName: "CasADi::poly_coeff"
// cWrapperName: "CasADi__poly_coeff"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// params: [ConstRef (CasadiClass SX),ConstRef (CasadiClass SX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1)"
// call: "CasADi::poly_coeff(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1);
CasADi::Matrix< CasADi::SXElement >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SXElement >* x0, CasADi::Matrix< CasADi::SXElement >* x1){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);
    CasADi::Matrix< CasADi::SXElement > const & x1_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x1);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::poly_coeff(x0_, x1_) );
}


// ================== function "CasADi::poly_roots" ===============
// cppName: "CasADi::poly_roots"
// cWrapperName: "CasADi__poly_roots"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__poly_roots(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::poly_roots(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__poly_roots(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__poly_roots(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::poly_roots(x0_) );
}


// ================== function "CasADi::eig_symbolic" ===============
// cppName: "CasADi::eig_symbolic"
// cWrapperName: "CasADi__eig_symbolic"
// protoArgs: "(CasADi::Matrix< CasADi::SXElement >* x0)"
// params: [ConstRef (CasadiClass SX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SXElement >*"
// proto: "CasADi::Matrix< CasADi::SXElement >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SXElement >* x0)"
// call: "CasADi::eig_symbolic(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SXElement >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SXElement >* x0);
CasADi::Matrix< CasADi::SXElement >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SXElement >* x0){
    CasADi::Matrix< CasADi::SXElement > const & x0_ = Marshaling<CasADi::Matrix< CasADi::SXElement > const &,CasADi::Matrix< CasADi::SXElement >*>::marshal(x0);

    return WrapReturn< CasADi::Matrix< CasADi::SXElement >*, CasADi::Matrix< CasADi::SXElement > >::wrapReturn( CasADi::eig_symbolic(x0_) );
}


// ================== function "CasADi::horzcat''''" ===============
// cppName: "CasADi::horzcat''''"
// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::horzsplit''''''''''" ===============
// cppName: "CasADi::horzsplit''''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1);
std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit'''''''''''" ===============
// cppName: "CasADi::horzsplit'''''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// params: [ConstRef (CasadiClass MX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1);
std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit''''''''''''" ===============
// cppName: "CasADi::horzsplit''''''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::horzsplit(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);
std::vector< CasADi::MX* >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::vertcat''''" ===============
// cppName: "CasADi::vertcat''''"
// cWrapperName: "CasADi__vertcat_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::vertsplit''''''''''" ===============
// cppName: "CasADi::vertsplit''''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector< int >* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1);
std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< int > x1_ = Marshaling<std::vector< int >,std::vector< int >*>::marshal(x1);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit'''''''''''" ===============
// cppName: "CasADi::vertsplit'''''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// params: [ConstRef (CasadiClass MX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1);
std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit''''''''''''" ===============
// cppName: "CasADi::vertsplit''''''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::vertsplit(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);
std::vector< CasADi::MX* >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::vertsplit(x0_) );
}


// ================== function "CasADi::blockcat'''" ===============
// cppName: "CasADi::blockcat'''"
// cWrapperName: "CasADi__blockcat_TIC_TIC_TIC"
// protoArgs: "(std::vector< std::vector< CasADi::MX* >* >* x0)"
// params: [ConstRef (StdVec (StdVec (CasadiClass MX)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector< std::vector< CasADi::MX* >* >* x0)"
// call: "CasADi::blockcat(x0_)"
extern "C"
    CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector< std::vector< CasADi::MX* >* >* x0);
CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector< std::vector< CasADi::MX* >* >* x0){
    std::vector< std::vector< CasADi::MX > > x0_ = Marshaling<std::vector< std::vector< CasADi::MX > >,std::vector< std::vector< CasADi::MX* >* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::blockcat(x0_) );
}


// ================== function "CasADi::blocksplit''''''''''''" ===============
// cppName: "CasADi::blocksplit''''''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec CInt),ConstRef (StdVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2);
std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector< int >* x1, std::vector< int >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,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);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit'''''''''''''" ===============
// cppName: "CasADi::blocksplit'''''''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass MX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2);
std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( CasADi::blocksplit(x0_, x1_, x2_) );
}


// ================== function "CasADi::blocksplit''''''''''''''" ===============
// cppName: "CasADi::blocksplit''''''''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// params: [ConstRef (CasadiClass MX),CInt]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1)"
// call: "CasADi::blocksplit(x0_, x1_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1);
std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( CasADi::blocksplit(x0_, x1_) );
}


// ================== function "CasADi::blocksplit'''''''''''''''" ===============
// cppName: "CasADi::blocksplit'''''''''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< std::vector< CasADi::MX* >* >*"
// proto: "std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::blocksplit(x0_)"
extern "C"
    std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);
std::vector< std::vector< CasADi::MX* >* >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< std::vector< std::vector< CasADi::MX* >* >*, std::vector< std::vector< CasADi::MX > > >::wrapReturn( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::veccat'''" ===============
// cppName: "CasADi::veccat'''"
// cWrapperName: "CasADi__veccat_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::veccat(x0_)"
extern "C"
    CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::veccat(x0_) );
}


// ================== function "CasADi::vecNZcat'''" ===============
// cppName: "CasADi::vecNZcat'''"
// cWrapperName: "CasADi__vecNZcat_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::vecNZcat(x0_)"
extern "C"
    CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::norm_F'''" ===============
// cppName: "CasADi::norm_F'''"
// cWrapperName: "CasADi__norm_F_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__norm_F_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::norm_F(x0_)"
extern "C"
    CasADi::MX* CasADi__norm_F_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__norm_F_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::norm_F(x0_) );
}


// ================== function "CasADi::norm_2'''" ===============
// cppName: "CasADi::norm_2'''"
// cWrapperName: "CasADi__norm_2_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__norm_2_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::norm_2(x0_)"
extern "C"
    CasADi::MX* CasADi__norm_2_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__norm_2_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::norm_2(x0_) );
}


// ================== function "CasADi::norm_1'''" ===============
// cppName: "CasADi::norm_1'''"
// cWrapperName: "CasADi__norm_1_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__norm_1_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::norm_1(x0_)"
extern "C"
    CasADi::MX* CasADi__norm_1_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__norm_1_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::norm_1(x0_) );
}


// ================== function "CasADi::norm_inf'''" ===============
// cppName: "CasADi::norm_inf'''"
// cWrapperName: "CasADi__norm_inf_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__norm_inf_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::norm_inf(x0_)"
extern "C"
    CasADi::MX* CasADi__norm_inf_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__norm_inf_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::transpose''''" ===============
// cppName: "CasADi::transpose''''"
// cWrapperName: "CasADi__transpose_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__transpose_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::transpose(x0_)"
extern "C"
    CasADi::MX* CasADi__transpose_TIC_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__transpose_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::transpose(x0_) );
}


// ================== function "CasADi::mul''''''''''" ===============
// cppName: "CasADi::mul''''''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1, CasADi::Sparsity* x2)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::Sparsity* x2)"
// call: "CasADi::mul(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::Sparsity* x2);
CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::Sparsity* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    CasADi::Sparsity const & x2_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::mul(x0_, x1_, x2_) );
}


// ================== function "CasADi::mul'''''''''''" ===============
// cppName: "CasADi::mul'''''''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::mul(x0_, x1_) );
}


// ================== function "CasADi::mul''''''''''''" ===============
// cppName: "CasADi::mul''''''''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::mul(x0_)"
extern "C"
    CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::mul(x0_) );
}


// ================== function "CasADi::inner_prod'''" ===============
// cppName: "CasADi::inner_prod'''"
// cWrapperName: "CasADi__inner_prod_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__inner_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::inner_prod(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__inner_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__inner_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::inner_prod(x0_, x1_) );
}


// ================== function "CasADi::outer_prod'''" ===============
// cppName: "CasADi::outer_prod'''"
// cWrapperName: "CasADi__outer_prod_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__outer_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::outer_prod(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__outer_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__outer_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::outer_prod(x0_, x1_) );
}


// ================== function "CasADi::if_else'" ===============
// cppName: "CasADi::if_else'"
// cWrapperName: "CasADi__if_else_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__if_else_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"
// call: "CasADi::if_else(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__if_else_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2);
CasADi::MX* CasADi__if_else_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::if_else(x0_, x1_, x2_) );
}


// ================== function "CasADi::reshape'''''''" ===============
// cppName: "CasADi::reshape'''''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::Sparsity* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass Sparsity)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::Sparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::Sparsity* x1);
CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::Sparsity* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::Sparsity const & x1_ = Marshaling<CasADi::Sparsity const &,CasADi::Sparsity*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec''''" ===============
// cppName: "CasADi::vec''''"
// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__vec_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::MX* CasADi__vec_TIC_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__vec_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::vec(x0_) );
}


// ================== function "CasADi::vecNZ'''" ===============
// cppName: "CasADi::vecNZ'''"
// cWrapperName: "CasADi__vecNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__vecNZ_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::vecNZ(x0_)"
extern "C"
    CasADi::MX* CasADi__vecNZ_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__vecNZ_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::unite'''" ===============
// cppName: "CasADi::unite'''"
// cWrapperName: "CasADi__unite_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__unite_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::unite(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__unite_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__unite_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::simplify''" ===============
// cppName: "CasADi::simplify''"
// cWrapperName: "CasADi__simplify_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [Ref (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__simplify_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::simplify(x0_)"
extern "C"
    void CasADi__simplify_TIC_TIC(CasADi::MX* x0);
void CasADi__simplify_TIC_TIC(CasADi::MX* x0){
    CasADi::MX& x0_ = Marshaling<CasADi::MX&,CasADi::MX*>::marshal(x0);

    CasADi::simplify(x0_);
}


// ================== function "CasADi::trace'''" ===============
// cppName: "CasADi::trace'''"
// cWrapperName: "CasADi__trace_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__trace_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::trace(x0_)"
extern "C"
    CasADi::MX* CasADi__trace_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__trace_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::trace(x0_) );
}


// ================== function "CasADi::repmat'''" ===============
// cppName: "CasADi::repmat'''"
// cWrapperName: "CasADi__repmat_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1, int x2)"
// params: [ConstRef (CasadiClass MX),CInt,CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__repmat_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2)"
// call: "CasADi::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__repmat_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2);
CasADi::MX* CasADi__repmat_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::dense'''" ===============
// cppName: "CasADi::dense'''"
// cWrapperName: "CasADi__dense_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__dense_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::dense(x0_)"
extern "C"
    CasADi::MX* CasADi__dense_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__dense_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::dense(x0_) );
}


// ================== function "CasADi::createParent" ===============
// cppName: "CasADi::createParent"
// cWrapperName: "CasADi__createParent"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [Ref (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__createParent(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::createParent(x0_)"
extern "C"
    CasADi::MX* CasADi__createParent(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__createParent(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::createParent(x0_) );
}


// ================== function "CasADi::createParent'" ===============
// cppName: "CasADi::createParent'"
// cWrapperName: "CasADi__createParent_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// params: [ConstRef (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__createParent_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::createParent(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__createParent_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1);
CasADi::MX* CasADi__createParent_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1){
    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);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::createParent(x0_, x1_) );
}


// ================== function "CasADi::createParent''" ===============
// cppName: "CasADi::createParent''"
// cWrapperName: "CasADi__createParent_TIC_TIC"
// protoArgs: "(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::MX* >* x1)"
// params: [ConstRef (StdVec (CasadiClass Sparsity)),Ref (StdVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__createParent_TIC_TIC(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::createParent(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__createParent_TIC_TIC(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::MX* >* x1);
CasADi::MX* CasADi__createParent_TIC_TIC(std::vector< CasADi::Sparsity* >* x0, std::vector< CasADi::MX* >* x1){
    std::vector< CasADi::Sparsity > x0_ = Marshaling<std::vector< CasADi::Sparsity >,std::vector< CasADi::Sparsity* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::createParent(x0_, x1_) );
}


// ================== function "CasADi::countNodes'" ===============
// cppName: "CasADi::countNodes'"
// cWrapperName: "CasADi__countNodes_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__countNodes_TIC(CasADi::MX* x0)"
// call: "CasADi::countNodes(x0_)"
extern "C"
    int CasADi__countNodes_TIC(CasADi::MX* x0);
int CasADi__countNodes_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< int, int >::wrapReturn( CasADi::countNodes(x0_) );
}


// ================== function "CasADi::diag'''" ===============
// cppName: "CasADi::diag'''"
// cWrapperName: "CasADi__diag_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__diag_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::diag(x0_)"
extern "C"
    CasADi::MX* CasADi__diag_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__diag_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag''''" ===============
// cppName: "CasADi::blkdiag''''"
// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::sumCols'''" ===============
// cppName: "CasADi::sumCols'''"
// cWrapperName: "CasADi__sumCols_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__sumCols_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::sumCols(x0_)"
extern "C"
    CasADi::MX* CasADi__sumCols_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__sumCols_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumRows'''" ===============
// cppName: "CasADi::sumRows'''"
// cWrapperName: "CasADi__sumRows_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__sumRows_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::sumRows(x0_)"
extern "C"
    CasADi::MX* CasADi__sumRows_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__sumRows_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumAll'''" ===============
// cppName: "CasADi::sumAll'''"
// cWrapperName: "CasADi__sumAll_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__sumAll_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::sumAll(x0_)"
extern "C"
    CasADi::MX* CasADi__sumAll_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__sumAll_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::polyval'''" ===============
// cppName: "CasADi::polyval'''"
// cWrapperName: "CasADi__polyval_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__polyval_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::polyval(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__polyval_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__polyval_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::polyval(x0_, x1_) );
}


// ================== function "CasADi::getOperatorRepresentation'" ===============
// cppName: "CasADi::getOperatorRepresentation'"
// cWrapperName: "CasADi__getOperatorRepresentation_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector< std::string* >* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec StdString)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector< std::string* >* x1)"
// call: "CasADi::getOperatorRepresentation(x0_, x1_)"
extern "C"
    std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector< std::string* >* x1);
std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector< std::string* >* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< std::string > x1_ = Marshaling<std::vector< std::string >,std::vector< std::string* >*>::marshal(x1);

    return WrapReturn< std::string*, std::string >::wrapReturn( CasADi::getOperatorRepresentation(x0_, x1_) );
}


// ================== function "CasADi::substitute''" ===============
// cppName: "CasADi::substitute''"
// cWrapperName: "CasADi__substitute_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__substitute_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"
// call: "CasADi::substitute(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__substitute_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2);
CasADi::MX* CasADi__substitute_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    CasADi::MX const & x2_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::substitute'''" ===============
// cppName: "CasADi::substitute'''"
// cWrapperName: "CasADi__substitute_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// params: [ConstRef (StdVec (CasadiClass MX)),ConstRef (StdVec (CasadiClass MX)),ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__substitute_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// call: "CasADi::substitute(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__substitute_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2);
std::vector< CasADi::MX* >* CasADi__substitute_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::graph_substitute" ===============
// cppName: "CasADi::graph_substitute"
// cWrapperName: "CasADi__graph_substitute"
// protoArgs: "(CasADi::MX* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec (CasadiClass MX)),ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// call: "CasADi::graph_substitute(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2);
CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::graph_substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::graph_substitute'" ===============
// cppName: "CasADi::graph_substitute'"
// cWrapperName: "CasADi__graph_substitute_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// params: [ConstRef (StdVec (CasadiClass MX)),ConstRef (StdVec (CasadiClass MX)),ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__graph_substitute_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// call: "CasADi::graph_substitute(x0_, x1_, x2_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__graph_substitute_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2);
std::vector< CasADi::MX* >* CasADi__graph_substitute_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::graph_substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::substituteInPlace''''''" ===============
// cppName: "CasADi::substituteInPlace''''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, int x2)"
// params: [ConstRef (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),CBool]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, int x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, int x2);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, int x2){
    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);
    bool x2_ = Marshaling<bool,int>::marshal(x2);

    CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::substituteInPlace'''''''" ===============
// cppName: "CasADi::substituteInPlace'''''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// params: [ConstRef (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::substituteInPlace(x0_, x1_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1){
    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::substituteInPlace(x0_, x1_);
}


// ================== function "CasADi::substituteInPlace''''''''" ===============
// cppName: "CasADi::substituteInPlace''''''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, int x3)"
// params: [ConstRef (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),CBool]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, int x3)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, int x3);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, int x3){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,int>::marshal(x3);

    CasADi::substituteInPlace(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::substituteInPlace'''''''''" ===============
// cppName: "CasADi::substituteInPlace'''''''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// params: [ConstRef (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);

    CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::extractShared'''" ===============
// cppName: "CasADi::extractShared'''"
// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3, std::string* x4)"
// params: [Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),ConstRef StdString,ConstRef StdString]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3, std::string* x4)"
// call: "CasADi::extractShared(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    void CasADi__extractShared_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3, std::string* x4);
void CasADi__extractShared_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3, std::string* x4){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);
    std::string const & x4_ = Marshaling<std::string const &,std::string*>::marshal(x4);

    CasADi::extractShared(x0_, x1_, x2_, x3_, x4_);
}


// ================== function "CasADi::extractShared''''" ===============
// cppName: "CasADi::extractShared''''"
// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3)"
// params: [Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),ConstRef StdString]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3)"
// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3);
void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2, std::string* x3){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);
    std::string const & x3_ = Marshaling<std::string const &,std::string*>::marshal(x3);

    CasADi::extractShared(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::extractShared'''''" ===============
// cppName: "CasADi::extractShared'''''"
// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// params: [Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX)),Ref (StdVec (CasadiClass MX))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2)"
// call: "CasADi::extractShared(x0_, x1_, x2_)"
extern "C"
    void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2);
void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1, std::vector< CasADi::MX* >* x2){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);
    std::vector< CasADi::MX > x2_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x2);

    CasADi::extractShared(x0_, x1_, x2_);
}


// ================== function "CasADi::printCompact'''" ===============
// cppName: "CasADi::printCompact'''"
// cWrapperName: "CasADi__printCompact_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__printCompact_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::printCompact(x0_)"
extern "C"
    void CasADi__printCompact_TIC_TIC_TIC(CasADi::MX* x0);
void CasADi__printCompact_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    CasADi::printCompact(x0_);
}


// ================== function "CasADi::jacobian'" ===============
// cppName: "CasADi::jacobian'"
// cWrapperName: "CasADi__jacobian_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__jacobian_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::jacobian(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__jacobian_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__jacobian_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::jacobian(x0_, x1_) );
}


// ================== function "CasADi::gradient'" ===============
// cppName: "CasADi::gradient'"
// cWrapperName: "CasADi__gradient_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__gradient_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::gradient(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__gradient_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__gradient_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::gradient(x0_, x1_) );
}


// ================== function "CasADi::tangent'" ===============
// cppName: "CasADi::tangent'"
// cWrapperName: "CasADi__tangent_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__tangent_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::tangent(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__tangent_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__tangent_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::tangent(x0_, x1_) );
}


// ================== function "CasADi::nullspace'''" ===============
// cppName: "CasADi::nullspace'''"
// cWrapperName: "CasADi__nullspace_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__nullspace_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::nullspace(x0_)"
extern "C"
    CasADi::MX* CasADi__nullspace_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__nullspace_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::det'''" ===============
// cppName: "CasADi::det'''"
// cWrapperName: "CasADi__det_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__det_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::det(x0_)"
extern "C"
    CasADi::MX* CasADi__det_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__det_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::det(x0_) );
}


// ================== function "CasADi::inv'''" ===============
// cppName: "CasADi::inv'''"
// cWrapperName: "CasADi__inv_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__inv_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::inv(x0_)"
extern "C"
    CasADi::MX* CasADi__inv_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__inv_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::inv(x0_) );
}


// ================== function "CasADi::getSymbols'" ===============
// cppName: "CasADi::getSymbols'"
// cWrapperName: "CasADi__getSymbols_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__getSymbols_TIC(CasADi::MX* x0)"
// call: "CasADi::getSymbols(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__getSymbols_TIC(CasADi::MX* x0);
std::vector< CasADi::MX* >* CasADi__getSymbols_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::getSymbols(x0_) );
}


// ================== function "CasADi::getSymbols''" ===============
// cppName: "CasADi::getSymbols''"
// cWrapperName: "CasADi__getSymbols_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__getSymbols_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::getSymbols(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__getSymbols_TIC_TIC(std::vector< CasADi::MX* >* x0);
std::vector< CasADi::MX* >* CasADi__getSymbols_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::getSymbols(x0_) );
}


// ================== function "CasADi::dependsOn'" ===============
// cppName: "CasADi::dependsOn'"
// cWrapperName: "CasADi__dependsOn_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector< CasADi::MX* >* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__dependsOn_TIC(CasADi::MX* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::dependsOn(x0_, x1_)"
extern "C"
    int CasADi__dependsOn_TIC(CasADi::MX* x0, std::vector< CasADi::MX* >* x1);
int CasADi__dependsOn_TIC(CasADi::MX* x0, std::vector< CasADi::MX* >* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);

    return WrapReturn< int, bool >::wrapReturn( CasADi::dependsOn(x0_, x1_) );
}


// ================== function "CasADi::matrix_expand" ===============
// cppName: "CasADi::matrix_expand"
// cWrapperName: "CasADi__matrix_expand"
// protoArgs: "(CasADi::MX* x0, std::vector< CasADi::MX* >* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::matrix_expand(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector< CasADi::MX* >* x1);
CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector< CasADi::MX* >* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    std::vector< CasADi::MX > x1_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::matrix_expand(x0_, x1_) );
}


// ================== function "CasADi::matrix_expand'" ===============
// cppName: "CasADi::matrix_expand'"
// cWrapperName: "CasADi__matrix_expand_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (CasadiClass MX)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__matrix_expand_TIC(CasADi::MX* x0)"
// call: "CasADi::matrix_expand(x0_)"
extern "C"
    CasADi::MX* CasADi__matrix_expand_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__matrix_expand_TIC(CasADi::MX* x0){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::matrix_expand(x0_) );
}


// ================== function "CasADi::matrix_expand''" ===============
// cppName: "CasADi::matrix_expand''"
// cWrapperName: "CasADi__matrix_expand_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// params: [ConstRef (StdVec (CasadiClass MX)),ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__matrix_expand_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1)"
// call: "CasADi::matrix_expand(x0_, x1_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__matrix_expand_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1);
std::vector< CasADi::MX* >* CasADi__matrix_expand_TIC_TIC(std::vector< CasADi::MX* >* x0, std::vector< CasADi::MX* >* x1){
    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);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::matrix_expand(x0_, x1_) );
}


// ================== function "CasADi::matrix_expand'''" ===============
// cppName: "CasADi::matrix_expand'''"
// cWrapperName: "CasADi__matrix_expand_TIC_TIC_TIC"
// protoArgs: "(std::vector< CasADi::MX* >* x0)"
// params: [ConstRef (StdVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "std::vector< CasADi::MX* >*"
// proto: "std::vector< CasADi::MX* >* CasADi__matrix_expand_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0)"
// call: "CasADi::matrix_expand(x0_)"
extern "C"
    std::vector< CasADi::MX* >* CasADi__matrix_expand_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0);
std::vector< CasADi::MX* >* CasADi__matrix_expand_TIC_TIC_TIC(std::vector< CasADi::MX* >* x0){
    std::vector< CasADi::MX > x0_ = Marshaling<std::vector< CasADi::MX >,std::vector< CasADi::MX* >*>::marshal(x0);

    return WrapReturn< std::vector< CasADi::MX* >*, std::vector< CasADi::MX > >::wrapReturn( CasADi::matrix_expand(x0_) );
}


// ================== function "CasADi::kron'''" ===============
// cppName: "CasADi::kron'''"
// cWrapperName: "CasADi__kron_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__kron_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::kron(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__kron_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__kron_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::solve'''" ===============
// cppName: "CasADi::solve'''"
// cWrapperName: "CasADi__solve_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (CasadiClass MX),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__solve_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::solve(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__solve_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
CasADi::MX* CasADi__solve_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX const & x0_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::MX*, CasADi::MX >::wrapReturn( CasADi::solve(x0_, x1_) );
}


// ================== function "CasADi::collocationPoints" ===============
// cppName: "CasADi::collocationPoints"
// cWrapperName: "CasADi__collocationPoints"
// protoArgs: "(int x0, std::string* x1)"
// params: [CInt,ConstRef StdString]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__collocationPoints(int x0, std::string* x1)"
// call: "CasADi::collocationPoints(x0_, x1_)"
extern "C"
    std::vector< double >* CasADi__collocationPoints(int x0, std::string* x1);
std::vector< double >* CasADi__collocationPoints(int x0, std::string* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    std::string const & x1_ = Marshaling<std::string const &,std::string*>::marshal(x1);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( CasADi::collocationPoints(x0_, x1_) );
}


// ================== function "CasADi::collocationPoints'" ===============
// cppName: "CasADi::collocationPoints'"
// cWrapperName: "CasADi__collocationPoints_TIC"
// protoArgs: "(int x0)"
// params: [CInt]
// args: "(x0_)"
// cWrapperRetType: "std::vector< double >*"
// proto: "std::vector< double >* CasADi__collocationPoints_TIC(int x0)"
// call: "CasADi::collocationPoints(x0_)"
extern "C"
    std::vector< double >* CasADi__collocationPoints_TIC(int x0);
std::vector< double >* CasADi__collocationPoints_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return WrapReturn< std::vector< double >*, std::vector< double > >::wrapReturn( CasADi::collocationPoints(x0_) );
}


// ================== function "CasADi::collocationInterpolators" ===============
// cppName: "CasADi::collocationInterpolators"
// cWrapperName: "CasADi__collocationInterpolators"
// protoArgs: "(std::vector< double >* x0, std::vector< std::vector< double >* >* x1, std::vector< double >* x2)"
// params: [ConstRef (StdVec CDouble),Ref (StdVec (StdVec CDouble)),Ref (StdVec CDouble)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__collocationInterpolators(std::vector< double >* x0, std::vector< std::vector< double >* >* x1, std::vector< double >* x2)"
// call: "CasADi::collocationInterpolators(x0_, x1_, x2_)"
extern "C"
    void CasADi__collocationInterpolators(std::vector< double >* x0, std::vector< std::vector< double >* >* x1, std::vector< double >* x2);
void CasADi__collocationInterpolators(std::vector< double >* x0, std::vector< std::vector< double >* >* x1, std::vector< double >* x2){
    std::vector< double > x0_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x0);
    std::vector< std::vector< double > > x1_ = Marshaling<std::vector< std::vector< double > >,std::vector< std::vector< double >* >*>::marshal(x1);
    std::vector< double > x2_ = Marshaling<std::vector< double >,std::vector< double >*>::marshal(x2);

    CasADi::collocationInterpolators(x0_, x1_, x2_);
}


// ================== function "CasADi::explicitRK" ===============
// cppName: "CasADi::explicitRK"
// cWrapperName: "CasADi__explicitRK"
// protoArgs: "(CasADi::Function* x0, CasADi::MX* x1, int x2, int x3)"
// params: [Ref (CasadiClass Function),ConstRef (CasadiClass MX),CInt,CInt]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__explicitRK(CasADi::Function* x0, CasADi::MX* x1, int x2, int x3)"
// call: "CasADi::explicitRK(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Function* CasADi__explicitRK(CasADi::Function* x0, CasADi::MX* x1, int x2, int x3);
CasADi::Function* CasADi__explicitRK(CasADi::Function* x0, CasADi::MX* x1, int x2, int x3){
    CasADi::Function& x0_ = Marshaling<CasADi::Function&,CasADi::Function*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( CasADi::explicitRK(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::explicitRK'" ===============
// cppName: "CasADi::explicitRK'"
// cWrapperName: "CasADi__explicitRK_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::MX* x1, int x2)"
// params: [Ref (CasadiClass Function),ConstRef (CasadiClass MX),CInt]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__explicitRK_TIC(CasADi::Function* x0, CasADi::MX* x1, int x2)"
// call: "CasADi::explicitRK(x0_, x1_, x2_)"
extern "C"
    CasADi::Function* CasADi__explicitRK_TIC(CasADi::Function* x0, CasADi::MX* x1, int x2);
CasADi::Function* CasADi__explicitRK_TIC(CasADi::Function* x0, CasADi::MX* x1, int x2){
    CasADi::Function& x0_ = Marshaling<CasADi::Function&,CasADi::Function*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( CasADi::explicitRK(x0_, x1_, x2_) );
}


// ================== function "CasADi::explicitRK''" ===============
// cppName: "CasADi::explicitRK''"
// cWrapperName: "CasADi__explicitRK_TIC_TIC"
// protoArgs: "(CasADi::Function* x0, CasADi::MX* x1)"
// params: [Ref (CasadiClass Function),ConstRef (CasadiClass MX)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__explicitRK_TIC_TIC(CasADi::Function* x0, CasADi::MX* x1)"
// call: "CasADi::explicitRK(x0_, x1_)"
extern "C"
    CasADi::Function* CasADi__explicitRK_TIC_TIC(CasADi::Function* x0, CasADi::MX* x1);
CasADi::Function* CasADi__explicitRK_TIC_TIC(CasADi::Function* x0, CasADi::MX* x1){
    CasADi::Function& x0_ = Marshaling<CasADi::Function&,CasADi::Function*>::marshal(x0);
    CasADi::MX const & x1_ = Marshaling<CasADi::MX const &,CasADi::MX*>::marshal(x1);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( CasADi::explicitRK(x0_, x1_) );
}


// ================== function "CasADi::explicitRK'''" ===============
// cppName: "CasADi::explicitRK'''"
// cWrapperName: "CasADi__explicitRK_TIC_TIC_TIC"
// protoArgs: "(CasADi::Function* x0)"
// params: [Ref (CasadiClass Function)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Function*"
// proto: "CasADi::Function* CasADi__explicitRK_TIC_TIC_TIC(CasADi::Function* x0)"
// call: "CasADi::explicitRK(x0_)"
extern "C"
    CasADi::Function* CasADi__explicitRK_TIC_TIC_TIC(CasADi::Function* x0);
CasADi::Function* CasADi__explicitRK_TIC_TIC_TIC(CasADi::Function* x0){
    CasADi::Function& x0_ = Marshaling<CasADi::Function&,CasADi::Function*>::marshal(x0);

    return WrapReturn< CasADi::Function*, CasADi::Function >::wrapReturn( CasADi::explicitRK(x0_) );
}