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

#include <swiginclude.hpp>
#include "../marshal.hpp"
#include <symbolic/functor_internal.hpp>
#include <symbolic/fx/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;
}
extern "C"
    void delete_std__vector_CasADi__SXFunction_(std::vector<CasADi::SXFunction* >* obj);
void delete_std__vector_CasADi__SXFunction_(std::vector<CasADi::SXFunction* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__SXFunction__(std::vector<std::vector<CasADi::SXFunction* > >* obj);
void delete_std__vector_std__vector_CasADi__SXFunction__(std::vector<std::vector<CasADi::SXFunction* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__SXFunction___(std::vector<std::vector<std::vector<CasADi::SXFunction* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__SXFunction___(std::vector<std::vector<std::vector<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, bool* x2, bool* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3)"
// call: "obj->jac(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3);
CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,bool*>::marshal(x2);
    bool x3_ = Marshaling<bool,bool*>::marshal(x3);

    return new CasADi::Matrix< CasADi::SX >( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== 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: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1)"
// call: "obj->grad(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1);
CasADi::Matrix< CasADi::SX >* 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 new CasADi::Matrix< CasADi::SX >( obj->grad(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: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1)"
// call: "obj->hess(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1);
CasADi::Matrix< CasADi::SX >* 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 new CasADi::Matrix< CasADi::SX >( obj->hess(x0_, x1_) );
}


// ================== Normal method: "getAlgorithmSize" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getAlgorithmSize"
// cWrapperName: "CasADi__SXFunction__getAlgorithmSize"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->getAlgorithmSize();
}


// ================== Normal method: "getWorkSize" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::getWorkSize"
// cWrapperName: "CasADi__SXFunction__getWorkSize"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec 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 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: Val (NonVec 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 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: Val (NonVec 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 obj->getAtomicOutput(x0_);
}


// ================== Normal method: "countNodes" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction::countNodes"
// cWrapperName: "CasADi__SXFunction__countNodes"
// protoArgs: "(CasADi::SXFunction* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->countNodes();
}


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

    return new std::vector<CasADi::SX >( obj->getFree() );
}


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

    return new CasADi::SXFunction( obj->indexed_one_based(x0_) );
}


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

    return new CasADi::SXFunction( obj->indexed_zero_based(x0_) );
}


// ================== Constructor method: "SXFunction'" ===============
// class: "CasADi::SXFunction"
// cppName: "CasADi::SXFunction"
// cWrapperName: "CasADi__SXFunction__SXFunction_TIC"
// protoArgs: "(CasADi::MXFunction* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (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 x0_ = Marshaling<CasADi::MXFunction,CasADi::MXFunction*>::marshal(x0);

    return new CasADi::SXFunction( CasADi::SXFunction(x0_) );
}


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

    return new CasADi::SXFunction( 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::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXFunction))
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1)"
// call: "CasADi::SXFunction(x0_, x1_)"
extern "C"
    CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1);
CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);
    std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x1);

    return new CasADi::SXFunction( CasADi::SXFunction(x0_, x1_) );
}


// ================== delete CasadiClass MXFunction===============
// classType: CasadiClass MXFunction
extern "C"
    void delete_CasADi__MXFunction(CasADi::MXFunction* obj);
void delete_CasADi__MXFunction(CasADi::MXFunction* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__MXFunction_(std::vector<CasADi::MXFunction* >* obj);
void delete_std__vector_CasADi__MXFunction_(std::vector<CasADi::MXFunction* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__MXFunction__(std::vector<std::vector<CasADi::MXFunction* > >* obj);
void delete_std__vector_std__vector_CasADi__MXFunction__(std::vector<std::vector<CasADi::MXFunction* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__MXFunction___(std::vector<std::vector<std::vector<CasADi::MXFunction* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__MXFunction___(std::vector<std::vector<std::vector<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: Val (NonVec 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 obj->getAlgorithmSize();
}


// ================== Normal method: "getWorkSize" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::getWorkSize"
// cWrapperName: "CasADi__MXFunction__getWorkSize"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->getWorkSize();
}


// ================== Normal method: "countNodes" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::countNodes"
// cWrapperName: "CasADi__MXFunction__countNodes"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->countNodes();
}


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

    return new bool( obj->checkNode() );
}


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

    return new CasADi::MX( obj->jac(x0_, x1_, x2_, x3_) );
}


// ================== 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: Val (NonVec (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 new CasADi::MX( obj->grad(x0_, x1_) );
}


// ================== Normal method: "getFree" ===============
// class: "CasADi::MXFunction"
// cppName: "CasADi::MXFunction::getFree"
// cWrapperName: "CasADi__MXFunction__getFree"
// protoArgs: "(CasADi::MXFunction* obj)"
// args: "()"
// rettype: Val (Vec (NonVec (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 new std::vector<CasADi::MX >( 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: Val (NonVec 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);

    return obj->generateLiftingFunctions(x0_, x1_);
}


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

    return new CasADi::MXFunction( CasADi::MXFunction(x0_) );
}


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


// ================== delete CasadiClass FX===============
// classType: CasadiClass FX
extern "C"
    void delete_CasADi__FX(CasADi::FX* obj);
void delete_CasADi__FX(CasADi::FX* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__FX_(std::vector<CasADi::FX* >* obj);
void delete_std__vector_CasADi__FX_(std::vector<CasADi::FX* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__FX__(std::vector<std::vector<CasADi::FX* > >* obj);
void delete_std__vector_std__vector_CasADi__FX__(std::vector<std::vector<CasADi::FX* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__FX___(std::vector<std::vector<std::vector<CasADi::FX* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__FX___(std::vector<std::vector<std::vector<CasADi::FX* > > >* obj){
    delete obj;
}

// ================== Normal method: "inputScheme" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::inputScheme"
// cWrapperName: "CasADi__FX__inputScheme"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass IOScheme))
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__FX__inputScheme(CasADi::FX* obj)"
// call: "obj->inputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__FX__inputScheme(CasADi::FX* obj);
CasADi::IOScheme* CasADi__FX__inputScheme(CasADi::FX* obj){

    return new CasADi::IOScheme( obj->inputScheme() );
}


// ================== Normal method: "outputScheme" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::outputScheme"
// cWrapperName: "CasADi__FX__outputScheme"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass IOScheme))
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__FX__outputScheme(CasADi::FX* obj)"
// call: "obj->outputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__FX__outputScheme(CasADi::FX* obj);
CasADi::IOScheme* CasADi__FX__outputScheme(CasADi::FX* obj){

    return new CasADi::IOScheme( obj->outputScheme() );
}


// ================== Normal method: "setInputScheme" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::setInputScheme"
// cWrapperName: "CasADi__FX__setInputScheme"
// protoArgs: "(CasADi::FX* obj, CasADi::IOScheme* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__setInputScheme(CasADi::FX* obj, CasADi::IOScheme* x0)"
// call: "obj->setInputScheme(x0_)"
extern "C"
    void CasADi__FX__setInputScheme(CasADi::FX* obj, CasADi::IOScheme* x0);
void CasADi__FX__setInputScheme(CasADi::FX* obj, CasADi::IOScheme* x0){
    CasADi::IOScheme x0_ = Marshaling<CasADi::IOScheme,CasADi::IOScheme*>::marshal(x0);

    return obj->setInputScheme(x0_);
}


// ================== Normal method: "setOutputScheme" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::setOutputScheme"
// cWrapperName: "CasADi__FX__setOutputScheme"
// protoArgs: "(CasADi::FX* obj, CasADi::IOScheme* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__setOutputScheme(CasADi::FX* obj, CasADi::IOScheme* x0)"
// call: "obj->setOutputScheme(x0_)"
extern "C"
    void CasADi__FX__setOutputScheme(CasADi::FX* obj, CasADi::IOScheme* x0);
void CasADi__FX__setOutputScheme(CasADi::FX* obj, CasADi::IOScheme* x0){
    CasADi::IOScheme x0_ = Marshaling<CasADi::IOScheme,CasADi::IOScheme*>::marshal(x0);

    return obj->setOutputScheme(x0_);
}


// ================== Normal method: "getInputScheme" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::getInputScheme"
// cWrapperName: "CasADi__FX__getInputScheme"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass IOScheme))
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__FX__getInputScheme(CasADi::FX* obj)"
// call: "obj->getInputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__FX__getInputScheme(CasADi::FX* obj);
CasADi::IOScheme* CasADi__FX__getInputScheme(CasADi::FX* obj){

    return new CasADi::IOScheme( obj->getInputScheme() );
}


// ================== Normal method: "getOutputScheme" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::getOutputScheme"
// cWrapperName: "CasADi__FX__getOutputScheme"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass IOScheme))
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__FX__getOutputScheme(CasADi::FX* obj)"
// call: "obj->getOutputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__FX__getOutputScheme(CasADi::FX* obj);
CasADi::IOScheme* CasADi__FX__getOutputScheme(CasADi::FX* obj){

    return new CasADi::IOScheme( obj->getOutputScheme() );
}


// ================== Normal method: "evaluate" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::evaluate"
// cWrapperName: "CasADi__FX__evaluate"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__evaluate(CasADi::FX* obj)"
// call: "obj->evaluate()"
extern "C"
    void CasADi__FX__evaluate(CasADi::FX* obj);
void CasADi__FX__evaluate(CasADi::FX* obj){

    return obj->evaluate();
}


// ================== Normal method: "solve" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::solve"
// cWrapperName: "CasADi__FX__solve"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__solve(CasADi::FX* obj)"
// call: "obj->solve()"
extern "C"
    void CasADi__FX__solve(CasADi::FX* obj);
void CasADi__FX__solve(CasADi::FX* obj){

    return obj->solve();
}


// ================== Normal method: "jacobian" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::jacobian"
// cWrapperName: "CasADi__FX__jacobian"
// protoArgs: "(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: Val (NonVec (CasadiClass FX))
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__FX__jacobian(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3)"
// call: "obj->jacobian(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::FX* CasADi__FX__jacobian(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3);
CasADi::FX* CasADi__FX__jacobian(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    bool x2_ = Marshaling<bool,bool*>::marshal(x2);
    bool x3_ = Marshaling<bool,bool*>::marshal(x3);

    return new CasADi::FX( obj->jacobian(x0_, x1_, x2_, x3_) );
}


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

    return new CasADi::FX( obj->gradient(x0_, x1_) );
}


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

    return new CasADi::FX( obj->hessian(x0_, x1_) );
}


// ================== Normal method: "fullJacobian" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::fullJacobian"
// cWrapperName: "CasADi__FX__fullJacobian"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass FX))
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__FX__fullJacobian(CasADi::FX* obj)"
// call: "obj->fullJacobian()"
extern "C"
    CasADi::FX* CasADi__FX__fullJacobian(CasADi::FX* obj);
CasADi::FX* CasADi__FX__fullJacobian(CasADi::FX* obj){

    return new CasADi::FX( obj->fullJacobian() );
}


// ================== Normal method: "call" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::call"
// cWrapperName: "CasADi__FX__call"
// protoArgs: "(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"
// args: "(x0_)"
// rettype: Val (Vec (NonVec (CasadiClass MX)))
// cWrapperRetType: "std::vector<CasADi::MX >*"
// proto: "std::vector<CasADi::MX >* CasADi__FX__call(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"
// call: "obj->call(x0_)"
extern "C"
    std::vector<CasADi::MX >* CasADi__FX__call(CasADi::FX* obj, std::vector<CasADi::MX* > * x0);
std::vector<CasADi::MX >* CasADi__FX__call(CasADi::FX* obj, std::vector<CasADi::MX* > * x0){
    std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);

    return new std::vector<CasADi::MX >( obj->call(x0_) );
}


// ================== Normal method: "call''" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::call''"
// cWrapperName: "CasADi__FX__call_TIC_TIC"
// protoArgs: "(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0)"
// args: "(x0_)"
// rettype: Val (Vec (Vec (NonVec (CasadiClass MX))))
// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"
// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0)"
// call: "obj->call(x0_)"
extern "C"
    std::vector<std::vector<CasADi::MX > >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0);
std::vector<std::vector<CasADi::MX > >* CasADi__FX__call_TIC_TIC(CasADi::FX* 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 new std::vector<std::vector<CasADi::MX > >( obj->call(x0_) );
}


// ================== Normal method: "evalMX" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::evalMX"
// cWrapperName: "CasADi__FX__evalMX"
// protoArgs: "(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"
// args: "(x0_)"
// rettype: Val (Vec (NonVec (CasadiClass MX)))
// cWrapperRetType: "std::vector<CasADi::MX >*"
// proto: "std::vector<CasADi::MX >* CasADi__FX__evalMX(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"
// call: "obj->evalMX(x0_)"
extern "C"
    std::vector<CasADi::MX >* CasADi__FX__evalMX(CasADi::FX* obj, std::vector<CasADi::MX* > * x0);
std::vector<CasADi::MX >* CasADi__FX__evalMX(CasADi::FX* obj, std::vector<CasADi::MX* > * x0){
    std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);

    return new std::vector<CasADi::MX >( obj->evalMX(x0_) );
}


// ================== Normal method: "evalSX" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::evalSX"
// cWrapperName: "CasADi__FX__evalSX"
// protoArgs: "(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// args: "(x0_)"
// rettype: Val (Vec (NonVec (CasadiClass SXMatrix)))
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "obj->evalSX(x0_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( obj->evalSX(x0_) );
}


// ================== Normal method: "generateCode" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::generateCode"
// cWrapperName: "CasADi__FX__generateCode"
// protoArgs: "(CasADi::FX* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__generateCode(CasADi::FX* obj, std::string* x0)"
// call: "obj->generateCode(x0_)"
extern "C"
    void CasADi__FX__generateCode(CasADi::FX* obj, std::string* x0);
void CasADi__FX__generateCode(CasADi::FX* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->generateCode(x0_);
}


// ================== Normal method: "checkNode" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::checkNode"
// cWrapperName: "CasADi__FX__checkNode"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__FX__checkNode(CasADi::FX* obj)"
// call: "obj->checkNode()"
extern "C"
    bool* CasADi__FX__checkNode(CasADi::FX* obj);
bool* CasADi__FX__checkNode(CasADi::FX* obj){

    return new bool( obj->checkNode() );
}


// ================== Normal method: "getStat" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::getStat"
// cWrapperName: "CasADi__FX__getStat"
// protoArgs: "(CasADi::FX* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass GenericType))
// cWrapperRetType: "CasADi::GenericType*"
// proto: "CasADi::GenericType* CasADi__FX__getStat(CasADi::FX* obj, std::string* x0)"
// call: "obj->getStat(x0_)"
extern "C"
    CasADi::GenericType* CasADi__FX__getStat(CasADi::FX* obj, std::string* x0);
CasADi::GenericType* CasADi__FX__getStat(CasADi::FX* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::GenericType( obj->getStat(x0_) );
}


// ================== Normal method: "symbolicInput" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::symbolicInput"
// cWrapperName: "CasADi__FX__symbolicInput"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (Vec (NonVec (CasadiClass MX)))
// cWrapperRetType: "std::vector<CasADi::MX >*"
// proto: "std::vector<CasADi::MX >* CasADi__FX__symbolicInput(CasADi::FX* obj)"
// call: "obj->symbolicInput()"
extern "C"
    std::vector<CasADi::MX >* CasADi__FX__symbolicInput(CasADi::FX* obj);
std::vector<CasADi::MX >* CasADi__FX__symbolicInput(CasADi::FX* obj){

    return new std::vector<CasADi::MX >( obj->symbolicInput() );
}


// ================== Normal method: "symbolicInputSX" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::symbolicInputSX"
// cWrapperName: "CasADi__FX__symbolicInputSX"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (Vec (NonVec (CasadiClass SXMatrix)))
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__symbolicInputSX(CasADi::FX* obj)"
// call: "obj->symbolicInputSX()"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__symbolicInputSX(CasADi::FX* obj);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__symbolicInputSX(CasADi::FX* obj){

    return new std::vector<CasADi::Matrix< CasADi::SX > >( obj->symbolicInputSX() );
}


// ================== Normal method: "addMonitor" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::addMonitor"
// cWrapperName: "CasADi__FX__addMonitor"
// protoArgs: "(CasADi::FX* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__addMonitor(CasADi::FX* obj, std::string* x0)"
// call: "obj->addMonitor(x0_)"
extern "C"
    void CasADi__FX__addMonitor(CasADi::FX* obj, std::string* x0);
void CasADi__FX__addMonitor(CasADi::FX* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->addMonitor(x0_);
}


// ================== Normal method: "removeMonitor" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::removeMonitor"
// cWrapperName: "CasADi__FX__removeMonitor"
// protoArgs: "(CasADi::FX* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__removeMonitor(CasADi::FX* obj, std::string* x0)"
// call: "obj->removeMonitor(x0_)"
extern "C"
    void CasADi__FX__removeMonitor(CasADi::FX* obj, std::string* x0);
void CasADi__FX__removeMonitor(CasADi::FX* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->removeMonitor(x0_);
}


// ================== Normal method: "checkInputs" ===============
// class: "CasADi::FX"
// cppName: "CasADi::FX::checkInputs"
// cWrapperName: "CasADi__FX__checkInputs"
// protoArgs: "(CasADi::FX* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__FX__checkInputs(CasADi::FX* obj)"
// call: "obj->checkInputs()"
extern "C"
    void CasADi__FX__checkInputs(CasADi::FX* obj);
void CasADi__FX__checkInputs(CasADi::FX* obj){

    return obj->checkInputs();
}


// ================== delete CasadiClass SharedObject===============
// classType: CasadiClass SharedObject
extern "C"
    void delete_CasADi__SharedObject(CasADi::SharedObject* obj);
void delete_CasADi__SharedObject(CasADi::SharedObject* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__SharedObject_(std::vector<CasADi::SharedObject* >* obj);
void delete_std__vector_CasADi__SharedObject_(std::vector<CasADi::SharedObject* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__SharedObject__(std::vector<std::vector<CasADi::SharedObject* > >* obj);
void delete_std__vector_std__vector_CasADi__SharedObject__(std::vector<std::vector<CasADi::SharedObject* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__SharedObject___(std::vector<std::vector<std::vector<CasADi::SharedObject* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__SharedObject___(std::vector<std::vector<std::vector<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: Val (NonVec 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){

    return obj->printPtr();
}


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

    return obj->init();
}


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

    return new bool( obj->isInit() );
}


// ================== Normal method: "assertInit" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::assertInit"
// cWrapperName: "CasADi__SharedObject__assertInit"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: Val (NonVec 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){

    return obj->assertInit();
}


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

    return new bool( obj->checkNode() );
}


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

    return obj->makeUnique(x0_);
}


// ================== Normal method: "makeUnique'" ===============
// class: "CasADi::SharedObject"
// cppName: "CasADi::SharedObject::makeUnique'"
// cWrapperName: "CasADi__SharedObject__makeUnique_TIC"
// protoArgs: "(CasADi::SharedObject* obj)"
// args: "()"
// rettype: Val (NonVec 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){

    return obj->makeUnique();
}


// ================== delete CasadiClass PrintableObject===============
// classType: CasadiClass PrintableObject
extern "C"
    void delete_CasADi__PrintableObject(CasADi::PrintableObject* obj);
void delete_CasADi__PrintableObject(CasADi::PrintableObject* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__PrintableObject_(std::vector<CasADi::PrintableObject* >* obj);
void delete_std__vector_CasADi__PrintableObject_(std::vector<CasADi::PrintableObject* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__PrintableObject__(std::vector<std::vector<CasADi::PrintableObject* > >* obj);
void delete_std__vector_std__vector_CasADi__PrintableObject__(std::vector<std::vector<CasADi::PrintableObject* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___(std::vector<std::vector<std::vector<CasADi::PrintableObject* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___(std::vector<std::vector<std::vector<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: Val (NonVec 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 new std::string( obj->getRepresentation() );
}


// ================== Normal method: "getDescription" ===============
// class: "CasADi::PrintableObject"
// cppName: "CasADi::PrintableObject::getDescription"
// cWrapperName: "CasADi__PrintableObject__getDescription"
// protoArgs: "(CasADi::PrintableObject* obj)"
// args: "()"
// rettype: Val (NonVec 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 new std::string( obj->getDescription() );
}


// ================== delete CasadiClass CRSSparsity===============
// classType: CasadiClass CRSSparsity
extern "C"
    void delete_CasADi__CRSSparsity(CasADi::CRSSparsity* obj);
void delete_CasADi__CRSSparsity(CasADi::CRSSparsity* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__CRSSparsity_(std::vector<CasADi::CRSSparsity* >* obj);
void delete_std__vector_CasADi__CRSSparsity_(std::vector<CasADi::CRSSparsity* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__CRSSparsity__(std::vector<std::vector<CasADi::CRSSparsity* > >* obj);
void delete_std__vector_std__vector_CasADi__CRSSparsity__(std::vector<std::vector<CasADi::CRSSparsity* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___(std::vector<std::vector<std::vector<CasADi::CRSSparsity* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___(std::vector<std::vector<std::vector<CasADi::CRSSparsity* > > >* obj){
    delete obj;
}

// ================== Normal method: "size1" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::size1"
// cWrapperName: "CasADi__CRSSparsity__size1"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__size1(CasADi::CRSSparsity* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__CRSSparsity__size1(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__size1(CasADi::CRSSparsity* obj){

    return obj->size1();
}


// ================== Normal method: "size2" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::size2"
// cWrapperName: "CasADi__CRSSparsity__size2"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__size2(CasADi::CRSSparsity* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__CRSSparsity__size2(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__size2(CasADi::CRSSparsity* obj){

    return obj->size2();
}


// ================== Normal method: "numel" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::numel"
// cWrapperName: "CasADi__CRSSparsity__numel"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__numel(CasADi::CRSSparsity* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__CRSSparsity__numel(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__numel(CasADi::CRSSparsity* obj){

    return obj->numel();
}


// ================== Normal method: "empty" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::empty"
// cWrapperName: "CasADi__CRSSparsity__empty"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CRSSparsity__empty(CasADi::CRSSparsity* obj)"
// call: "obj->empty()"
extern "C"
    bool* CasADi__CRSSparsity__empty(CasADi::CRSSparsity* obj);
bool* CasADi__CRSSparsity__empty(CasADi::CRSSparsity* obj){

    return new bool( obj->empty() );
}


// ================== Normal method: "null" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::null"
// cWrapperName: "CasADi__CRSSparsity__null"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CRSSparsity__null(CasADi::CRSSparsity* obj)"
// call: "obj->null()"
extern "C"
    bool* CasADi__CRSSparsity__null(CasADi::CRSSparsity* obj);
bool* CasADi__CRSSparsity__null(CasADi::CRSSparsity* obj){

    return new bool( obj->null() );
}


// ================== Normal method: "size" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::size"
// cWrapperName: "CasADi__CRSSparsity__size"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__size(CasADi::CRSSparsity* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__CRSSparsity__size(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__size(CasADi::CRSSparsity* obj){

    return obj->size();
}


// ================== Normal method: "sizeU" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::sizeU"
// cWrapperName: "CasADi__CRSSparsity__sizeU"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__sizeU(CasADi::CRSSparsity* obj)"
// call: "obj->sizeU()"
extern "C"
    int CasADi__CRSSparsity__sizeU(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__sizeU(CasADi::CRSSparsity* obj){

    return obj->sizeU();
}


// ================== Normal method: "sizeL" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::sizeL"
// cWrapperName: "CasADi__CRSSparsity__sizeL"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__sizeL(CasADi::CRSSparsity* obj)"
// call: "obj->sizeL()"
extern "C"
    int CasADi__CRSSparsity__sizeL(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__sizeL(CasADi::CRSSparsity* obj){

    return obj->sizeL();
}


// ================== Normal method: "sizeD" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::sizeD"
// cWrapperName: "CasADi__CRSSparsity__sizeD"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__sizeD(CasADi::CRSSparsity* obj)"
// call: "obj->sizeD()"
extern "C"
    int CasADi__CRSSparsity__sizeD(CasADi::CRSSparsity* obj);
int CasADi__CRSSparsity__sizeD(CasADi::CRSSparsity* obj){

    return obj->sizeD();
}


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

    return obj->col(x0_);
}


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

    return obj->rowind(x0_);
}


// ================== Normal method: "colRef" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::colRef"
// cWrapperName: "CasADi__CRSSparsity__colRef"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (Vec (NonVec CInt))
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj)"
// call: "obj->colRef()"
extern "C"
    std::vector<int >* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj);
std::vector<int >* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj){

    return new std::vector<int >( obj->colRef() );
}


// ================== Normal method: "rowindRef" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::rowindRef"
// cWrapperName: "CasADi__CRSSparsity__rowindRef"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (Vec (NonVec CInt))
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj)"
// call: "obj->rowindRef()"
extern "C"
    std::vector<int >* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj);
std::vector<int >* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj){

    return new std::vector<int >( obj->rowindRef() );
}


// ================== Normal method: "getRow" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::getRow"
// cWrapperName: "CasADi__CRSSparsity__getRow"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (Vec (NonVec CInt))
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj)"
// call: "obj->getRow()"
extern "C"
    std::vector<int >* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj);
std::vector<int >* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj){

    return new std::vector<int >( obj->getRow() );
}


// ================== Normal method: "getNZ" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::getNZ"
// cWrapperName: "CasADi__CRSSparsity__getNZ"
// protoArgs: "(CasADi::CRSSparsity* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__CRSSparsity__getNZ(CasADi::CRSSparsity* obj, int x0, int x1)"
// call: "obj->getNZ(x0_, x1_)"
extern "C"
    int CasADi__CRSSparsity__getNZ(CasADi::CRSSparsity* obj, int x0, int x1);
int CasADi__CRSSparsity__getNZ(CasADi::CRSSparsity* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return obj->getNZ(x0_, x1_);
}


// ================== Normal method: "getNZ''" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::getNZ''"
// cWrapperName: "CasADi__CRSSparsity__getNZ_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1)"
// args: "(x0_, x1_)"
// rettype: Val (Vec (NonVec CInt))
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1)"
// call: "obj->getNZ(x0_, x1_)"
extern "C"
    std::vector<int >* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1);
std::vector<int >* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* 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 new std::vector<int >( obj->getNZ(x0_, x1_) );
}


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

    return new bool( obj->hasNZ(x0_, x1_) );
}


// ================== Normal method: "getNZInplace" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::getNZInplace"
// cWrapperName: "CasADi__CRSSparsity__getNZInplace"
// protoArgs: "(CasADi::CRSSparsity* obj, std::vector<int >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector<int >* x0)"
// call: "obj->getNZInplace(x0_)"
extern "C"
    void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector<int >* x0);
void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector<int >* x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int >*>::marshal(x0);

    return obj->getNZInplace(x0_);
}


// ================== Normal method: "columnsSequential" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::columnsSequential"
// cWrapperName: "CasADi__CRSSparsity__columnsSequential"
// protoArgs: "(CasADi::CRSSparsity* obj, bool* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CRSSparsity__columnsSequential(CasADi::CRSSparsity* obj, bool* x0)"
// call: "obj->columnsSequential(x0_)"
extern "C"
    bool* CasADi__CRSSparsity__columnsSequential(CasADi::CRSSparsity* obj, bool* x0);
bool* CasADi__CRSSparsity__columnsSequential(CasADi::CRSSparsity* obj, bool* x0){
    bool x0_ = Marshaling<bool,bool*>::marshal(x0);

    return new bool( obj->columnsSequential(x0_) );
}


// ================== Normal method: "getElements" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::getElements"
// cWrapperName: "CasADi__CRSSparsity__getElements"
// protoArgs: "(CasADi::CRSSparsity* obj, bool* x0)"
// args: "(x0_)"
// rettype: Val (Vec (NonVec CInt))
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0)"
// call: "obj->getElements(x0_)"
extern "C"
    std::vector<int >* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0);
std::vector<int >* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0){
    bool x0_ = Marshaling<bool,bool*>::marshal(x0);

    return new std::vector<int >( obj->getElements(x0_) );
}


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

    return new CasADi::CRSSparsity( obj->unidirectionalColoring(x0_, x1_) );
}


// ================== Normal method: "unidirectionalColoring'" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::unidirectionalColoring'"
// cWrapperName: "CasADi__CRSSparsity__unidirectionalColoring_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0)"
// call: "obj->unidirectionalColoring(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0);
CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::CRSSparsity( obj->unidirectionalColoring(x0_) );
}


// ================== Normal method: "unidirectionalColoring''" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::unidirectionalColoring''"
// cWrapperName: "CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC(CasADi::CRSSparsity* obj)"
// call: "obj->unidirectionalColoring()"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC(CasADi::CRSSparsity* obj);
CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC(CasADi::CRSSparsity* obj){

    return new CasADi::CRSSparsity( obj->unidirectionalColoring() );
}


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

    return new CasADi::CRSSparsity( obj->starColoring(x0_, x1_) );
}


// ================== Normal method: "starColoring'" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::starColoring'"
// cWrapperName: "CasADi__CRSSparsity__starColoring_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC(CasADi::CRSSparsity* obj, int x0)"
// call: "obj->starColoring(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC(CasADi::CRSSparsity* obj, int x0);
CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC(CasADi::CRSSparsity* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::CRSSparsity( obj->starColoring(x0_) );
}


// ================== Normal method: "starColoring''" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::starColoring''"
// cWrapperName: "CasADi__CRSSparsity__starColoring_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC_TIC(CasADi::CRSSparsity* obj)"
// call: "obj->starColoring()"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC_TIC(CasADi::CRSSparsity* obj);
CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC_TIC(CasADi::CRSSparsity* obj){

    return new CasADi::CRSSparsity( obj->starColoring() );
}


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

    return new CasADi::CRSSparsity( obj->starColoring2(x0_, x1_) );
}


// ================== Normal method: "starColoring2'" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::starColoring2'"
// cWrapperName: "CasADi__CRSSparsity__starColoring2_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC(CasADi::CRSSparsity* obj, int x0)"
// call: "obj->starColoring2(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC(CasADi::CRSSparsity* obj, int x0);
CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC(CasADi::CRSSparsity* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::CRSSparsity( obj->starColoring2(x0_) );
}


// ================== Normal method: "starColoring2''" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::starColoring2''"
// cWrapperName: "CasADi__CRSSparsity__starColoring2_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC_TIC(CasADi::CRSSparsity* obj)"
// call: "obj->starColoring2()"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC_TIC(CasADi::CRSSparsity* obj);
CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC_TIC(CasADi::CRSSparsity* obj){

    return new CasADi::CRSSparsity( obj->starColoring2() );
}


// ================== Normal method: "dimString" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::dimString"
// cWrapperName: "CasADi__CRSSparsity__dimString"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec StdString)
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__CRSSparsity__dimString(CasADi::CRSSparsity* obj)"
// call: "obj->dimString()"
extern "C"
    std::string* CasADi__CRSSparsity__dimString(CasADi::CRSSparsity* obj);
std::string* CasADi__CRSSparsity__dimString(CasADi::CRSSparsity* obj){

    return new std::string( obj->dimString() );
}


// ================== Normal method: "spy'" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::spy'"
// cWrapperName: "CasADi__CRSSparsity__spy_TIC"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__CRSSparsity__spy_TIC(CasADi::CRSSparsity* obj)"
// call: "obj->spy()"
extern "C"
    void CasADi__CRSSparsity__spy_TIC(CasADi::CRSSparsity* obj);
void CasADi__CRSSparsity__spy_TIC(CasADi::CRSSparsity* obj){

    return obj->spy();
}


// ================== Normal method: "spyMatlab" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::spyMatlab"
// cWrapperName: "CasADi__CRSSparsity__spyMatlab"
// protoArgs: "(CasADi::CRSSparsity* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__CRSSparsity__spyMatlab(CasADi::CRSSparsity* obj, std::string* x0)"
// call: "obj->spyMatlab(x0_)"
extern "C"
    void CasADi__CRSSparsity__spyMatlab(CasADi::CRSSparsity* obj, std::string* x0);
void CasADi__CRSSparsity__spyMatlab(CasADi::CRSSparsity* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->spyMatlab(x0_);
}


// ================== Normal method: "hash" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity::hash"
// cWrapperName: "CasADi__CRSSparsity__hash"
// protoArgs: "(CasADi::CRSSparsity* obj)"
// args: "()"
// rettype: Val (NonVec CSize)
// cWrapperRetType: "size_t"
// proto: "size_t CasADi__CRSSparsity__hash(CasADi::CRSSparsity* obj)"
// call: "obj->hash()"
extern "C"
    size_t CasADi__CRSSparsity__hash(CasADi::CRSSparsity* obj);
size_t CasADi__CRSSparsity__hash(CasADi::CRSSparsity* obj){

    return obj->hash();
}


// ================== Constructor method: "CRSSparsity" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity"
// cWrapperName: "CasADi__CRSSparsity__CRSSparsity"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// call: "CasADi::CRSSparsity(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);
CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(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 new CasADi::CRSSparsity( CasADi::CRSSparsity(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "CRSSparsity'" ===============
// class: "CasADi::CRSSparsity"
// cppName: "CasADi::CRSSparsity"
// cWrapperName: "CasADi__CRSSparsity__CRSSparsity_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity_TIC()"
// call: "CasADi::CRSSparsity()"
extern "C"
    CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity_TIC();
CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity_TIC(){

    return new CasADi::CRSSparsity( CasADi::CRSSparsity() );
}


// ================== delete CasadiClass GenericType===============
// classType: CasadiClass GenericType
extern "C"
    void delete_CasADi__GenericType(CasADi::GenericType* obj);
void delete_CasADi__GenericType(CasADi::GenericType* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__GenericType_(std::vector<CasADi::GenericType* >* obj);
void delete_std__vector_CasADi__GenericType_(std::vector<CasADi::GenericType* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__GenericType__(std::vector<std::vector<CasADi::GenericType* > >* obj);
void delete_std__vector_std__vector_CasADi__GenericType__(std::vector<std::vector<CasADi::GenericType* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__GenericType___(std::vector<std::vector<std::vector<CasADi::GenericType* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__GenericType___(std::vector<std::vector<std::vector<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* x0)"
// args: "(x0_)"
// rettype: Val (NonVec StdString)
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__GenericType__get_type_description(CasADi::opt_type* x0)"
// call: "CasADi::GenericType::get_type_description(x0_)"
extern "C"
    std::string* CasADi__GenericType__get_type_description(CasADi::opt_type* x0);
std::string* CasADi__GenericType__get_type_description(CasADi::opt_type* x0){
    CasADi::opt_type x0_ = Marshaling<CasADi::opt_type,CasADi::opt_type*>::marshal(x0);

    return new std::string( 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: Val (NonVec 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 new std::string( 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: Val (NonVec (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 new CasADi::GenericType( 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: Val (NonVec (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 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0)"
// call: "obj->can_cast_to(x0_)"
extern "C"
    bool* CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0);
bool* 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 new bool( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// call: "obj->can_cast_to(x0_)"
extern "C"
    bool* CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0);
bool* CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0){
    CasADi::GenericType x0_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x0);

    return new bool( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__GenericType__isBool(CasADi::GenericType* obj)"
// call: "obj->isBool()"
extern "C"
    bool* CasADi__GenericType__isBool(CasADi::GenericType* obj);
bool* CasADi__GenericType__isBool(CasADi::GenericType* obj){

    return new bool( obj->isBool() );
}


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

    return new bool( obj->isInt() );
}


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

    return new bool( obj->isDouble() );
}


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

    return new bool( obj->isString() );
}


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

    return new bool( obj->isEmptyVector() );
}


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

    return new bool( obj->isIntVector() );
}


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

    return new bool( obj->isDoubleVector() );
}


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

    return new bool( obj->isStringVector() );
}


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

    return new bool( obj->isSharedObject() );
}


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

    return new bool( obj->isDictionary() );
}


// ================== Normal method: "isFX" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::isFX"
// cWrapperName: "CasADi__GenericType__isFX"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__GenericType__isFX(CasADi::GenericType* obj)"
// call: "obj->isFX()"
extern "C"
    bool* CasADi__GenericType__isFX(CasADi::GenericType* obj);
bool* CasADi__GenericType__isFX(CasADi::GenericType* obj){

    return new bool( obj->isFX() );
}


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

    return new bool( obj->toBool() );
}


// ================== Normal method: "toInt" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::toInt"
// cWrapperName: "CasADi__GenericType__toInt"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->toInt();
}


// ================== Normal method: "toDouble" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType::toDouble"
// cWrapperName: "CasADi__GenericType__toDouble"
// protoArgs: "(CasADi::GenericType* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// call: "obj->operator ==(x0_)"
extern "C"
    bool* CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0);
bool* CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0){
    CasADi::GenericType x0_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x0);

    return new bool( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0)"
// call: "obj->operator !=(x0_)"
extern "C"
    bool* CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0);
bool* CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0){
    CasADi::GenericType x0_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x0);

    return new bool( obj->operator !=(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


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

    return new CasADi::GenericType( CasADi::GenericType(x0_) );
}


// ================== Constructor method: "GenericType" ===============
// class: "CasADi::GenericType"
// cppName: "CasADi::GenericType"
// cWrapperName: "CasADi__GenericType__GenericType"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::GenericType( CasADi::GenericType() );
}


// ================== delete CasadiClass IOInterfaceFX===============
// classType: CasadiClass IOInterfaceFX
extern "C"
    void delete_CasADi__IOInterface_CasADi__FX_(CasADi::IOInterface< CasADi::FX >* obj);
void delete_CasADi__IOInterface_CasADi__FX_(CasADi::IOInterface< CasADi::FX >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__IOInterface_CasADi__FX__(std::vector<CasADi::IOInterface< CasADi::FX >* >* obj);
void delete_std__vector_CasADi__IOInterface_CasADi__FX__(std::vector<CasADi::IOInterface< CasADi::FX >* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___(std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > >* obj);
void delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___(std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____(std::vector<std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____(std::vector<std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > > >* obj){
    delete obj;
}

// ================== Normal method: "input" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::input"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___input"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input(CasADi::IOInterface< CasADi::FX >* obj, int x0)"
// call: "obj->input(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input(CasADi::IOInterface< CasADi::FX >* obj, int x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input(CasADi::IOInterface< CasADi::FX >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< double >( obj->input(x0_) );
}


// ================== Normal method: "input'" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::input'"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___input_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC(CasADi::IOInterface< CasADi::FX >* obj)"
// call: "obj->input()"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC(CasADi::IOInterface< CasADi::FX >* obj);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC(CasADi::IOInterface< CasADi::FX >* obj){

    return new CasADi::Matrix< double >( obj->input() );
}


// ================== Normal method: "input''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::input''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___input_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// call: "obj->input(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::Matrix< double >( obj->input(x0_) );
}


// ================== Normal method: "output" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::output"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___output"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output(CasADi::IOInterface< CasADi::FX >* obj, int x0)"
// call: "obj->output(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output(CasADi::IOInterface< CasADi::FX >* obj, int x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output(CasADi::IOInterface< CasADi::FX >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< double >( obj->output(x0_) );
}


// ================== Normal method: "output'" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::output'"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___output_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC(CasADi::IOInterface< CasADi::FX >* obj)"
// call: "obj->output()"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC(CasADi::IOInterface< CasADi::FX >* obj);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC(CasADi::IOInterface< CasADi::FX >* obj){

    return new CasADi::Matrix< double >( obj->output() );
}


// ================== Normal method: "output''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::output''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___output_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// call: "obj->output(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);
CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::Matrix< double >( obj->output(x0_) );
}


// ================== Normal method: "getNumInputs" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::getNumInputs"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___getNumInputs"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__FX___getNumInputs(CasADi::IOInterface< CasADi::FX >* obj)"
// call: "obj->getNumInputs()"
extern "C"
    int CasADi__IOInterface_CasADi__FX___getNumInputs(CasADi::IOInterface< CasADi::FX >* obj);
int CasADi__IOInterface_CasADi__FX___getNumInputs(CasADi::IOInterface< CasADi::FX >* obj){

    return obj->getNumInputs();
}


// ================== Normal method: "getNumOutputs" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::getNumOutputs"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___getNumOutputs"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__FX___getNumOutputs(CasADi::IOInterface< CasADi::FX >* obj)"
// call: "obj->getNumOutputs()"
extern "C"
    int CasADi__IOInterface_CasADi__FX___getNumOutputs(CasADi::IOInterface< CasADi::FX >* obj);
int CasADi__IOInterface_CasADi__FX___getNumOutputs(CasADi::IOInterface< CasADi::FX >* obj){

    return obj->getNumOutputs();
}


// ================== Normal method: "getInputScheme" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::getInputScheme"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___getInputScheme"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass IOScheme))
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getInputScheme(CasADi::IOInterface< CasADi::FX >* obj)"
// call: "obj->getInputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getInputScheme(CasADi::IOInterface< CasADi::FX >* obj);
CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getInputScheme(CasADi::IOInterface< CasADi::FX >* obj){

    return new CasADi::IOScheme( obj->getInputScheme() );
}


// ================== Normal method: "getOutputScheme" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::getOutputScheme"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___getOutputScheme"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass IOScheme))
// cWrapperRetType: "CasADi::IOScheme*"
// proto: "CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getOutputScheme(CasADi::IOInterface< CasADi::FX >* obj)"
// call: "obj->getOutputScheme()"
extern "C"
    CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getOutputScheme(CasADi::IOInterface< CasADi::FX >* obj);
CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getOutputScheme(CasADi::IOInterface< CasADi::FX >* obj){

    return new CasADi::IOScheme( obj->getOutputScheme() );
}


// ================== Normal method: "inputSchemeEntry" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::inputSchemeEntry"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___inputSchemeEntry"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__FX___inputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// call: "obj->inputSchemeEntry(x0_)"
extern "C"
    int CasADi__IOInterface_CasADi__FX___inputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);
int CasADi__IOInterface_CasADi__FX___inputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->inputSchemeEntry(x0_);
}


// ================== Normal method: "outputSchemeEntry" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::outputSchemeEntry"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___outputSchemeEntry"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__FX___outputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"
// call: "obj->outputSchemeEntry(x0_)"
extern "C"
    int CasADi__IOInterface_CasADi__FX___outputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);
int CasADi__IOInterface_CasADi__FX___outputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->outputSchemeEntry(x0_);
}


// ================== Normal method: "schemeEntry" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::schemeEntry"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___schemeEntry"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__IOInterface_CasADi__FX___schemeEntry(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2)"
// call: "obj->schemeEntry(x0_, x1_, x2_)"
extern "C"
    int CasADi__IOInterface_CasADi__FX___schemeEntry(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2);
int CasADi__IOInterface_CasADi__FX___schemeEntry(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2){
    CasADi::IOScheme x0_ = Marshaling<CasADi::IOScheme,CasADi::IOScheme*>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);
    bool x2_ = Marshaling<bool,bool*>::marshal(x2);

    return obj->schemeEntry(x0_, x1_, x2_);
}


// ================== Normal method: "setInput" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setInput"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setInput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setInput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1);
void CasADi__IOInterface_CasADi__FX___setInput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return obj->setInput(x0_, x1_);
}


// ================== Normal method: "setInput'" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0)"
// call: "obj->setInput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setInput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0);
void CasADi__IOInterface_CasADi__FX___setInput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return obj->setInput(x0_);
}


// ================== Normal method: "setOutput" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1);
void CasADi__IOInterface_CasADi__FX___setOutput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setOutput'" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0)"
// call: "obj->setOutput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0);
void CasADi__IOInterface_CasADi__FX___setOutput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return obj->setOutput(x0_);
}


// ================== Normal method: "setOutput''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1);
void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setInput'''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1);
void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* 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);

    return obj->setInput(x0_, x1_);
}


// ================== Normal method: "setInput''''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setInput''''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"
// call: "obj->setInput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0);
void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return obj->setInput(x0_);
}


// ================== Normal method: "setOutput'''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1);
void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* 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);

    return obj->setOutput(x0_, x1_);
}


// ================== Normal method: "setOutput''''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"
// call: "obj->setOutput(x0_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0);
void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return obj->setOutput(x0_);
}


// ================== Normal method: "setInput'''''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'''''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1);
void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return obj->setInput(x0_, x1_);
}


// ================== Normal method: "setOutput'''''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'''''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1);
void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return obj->setOutput(x0_, x1_);
}


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

    return obj->setInput(x0_, x1_);
}


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

    return obj->setInput(x0_);
}


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

    return obj->setOutput(x0_, x1_);
}


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

    return obj->setOutput(x0_);
}


// ================== Normal method: "setInput''''''''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setInput''''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// call: "obj->setInput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1);
void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return obj->setInput(x0_, x1_);
}


// ================== Normal method: "setOutput''''''''" ===============
// class: "CasADi::IOInterface< CasADi::FX >"
// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''''''''"
// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"
// call: "obj->setOutput(x0_, x1_)"
extern "C"
    void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1);
void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return obj->setOutput(x0_, x1_);
}


// ================== delete CasadiClass OptionsFunctionality===============
// classType: CasadiClass OptionsFunctionality
extern "C"
    void delete_CasADi__OptionsFunctionality(CasADi::OptionsFunctionality* obj);
void delete_CasADi__OptionsFunctionality(CasADi::OptionsFunctionality* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__OptionsFunctionality_(std::vector<CasADi::OptionsFunctionality* >* obj);
void delete_std__vector_CasADi__OptionsFunctionality_(std::vector<CasADi::OptionsFunctionality* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__OptionsFunctionality__(std::vector<std::vector<CasADi::OptionsFunctionality* > >* obj);
void delete_std__vector_std__vector_CasADi__OptionsFunctionality__(std::vector<std::vector<CasADi::OptionsFunctionality* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___(std::vector<std::vector<std::vector<CasADi::OptionsFunctionality* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___(std::vector<std::vector<std::vector<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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::GenericType x1_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x1);

    return 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: Val (NonVec (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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::GenericType( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->hasOption(x0_)"
extern "C"
    bool* CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0);
bool* CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new bool( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0)"
// call: "obj->hasSetOption(x0_)"
extern "C"
    bool* CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0);
bool* CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new bool( obj->hasSetOption(x0_) );
}


// ================== Normal method: "printOptions'" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::printOptions'"
// cWrapperName: "CasADi__OptionsFunctionality__printOptions_TIC"
// protoArgs: "(CasADi::OptionsFunctionality* obj)"
// args: "()"
// rettype: Val (NonVec 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){

    return obj->printOptions();
}


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

    return 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: Val (NonVec 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 x0_ = Marshaling<CasADi::OptionsFunctionality,CasADi::OptionsFunctionality*>::marshal(x0);

    return obj->copyOptions(x0_);
}


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

    return new bool( obj->checkNode() );
}


// ================== Normal method: "getOptionNames" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality::getOptionNames"
// cWrapperName: "CasADi__OptionsFunctionality__getOptionNames"
// protoArgs: "(CasADi::OptionsFunctionality* obj)"
// args: "()"
// rettype: Val (Vec (NonVec 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 new std::vector<std::string >( 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new std::string( 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: Val (NonVec (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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new std::string( 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: Val (Vec (NonVec (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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new std::vector<CasADi::GenericType >( 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return 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: Val (NonVec (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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::GenericType( obj->getOptionDefault(x0_) );
}


// ================== Constructor method: "OptionsFunctionality" ===============
// class: "CasADi::OptionsFunctionality"
// cppName: "CasADi::OptionsFunctionality"
// cWrapperName: "CasADi__OptionsFunctionality__OptionsFunctionality"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::OptionsFunctionality( CasADi::OptionsFunctionality() );
}


// ================== delete CasadiClass IpoptSolver===============
// classType: CasadiClass IpoptSolver
extern "C"
    void delete_CasADi__IpoptSolver(CasADi::IpoptSolver* obj);
void delete_CasADi__IpoptSolver(CasADi::IpoptSolver* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__IpoptSolver_(std::vector<CasADi::IpoptSolver* >* obj);
void delete_std__vector_CasADi__IpoptSolver_(std::vector<CasADi::IpoptSolver* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__IpoptSolver__(std::vector<std::vector<CasADi::IpoptSolver* > >* obj);
void delete_std__vector_std__vector_CasADi__IpoptSolver__(std::vector<std::vector<CasADi::IpoptSolver* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___(std::vector<std::vector<std::vector<CasADi::IpoptSolver* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___(std::vector<std::vector<std::vector<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: Val (NonVec (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 new CasADi::Matrix< double >( obj->getReducedHessian() );
}


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

    return new bool( obj->checkNode() );
}


// ================== Constructor method: "IpoptSolver" ===============
// class: "CasADi::IpoptSolver"
// cppName: "CasADi::IpoptSolver"
// cWrapperName: "CasADi__IpoptSolver__IpoptSolver"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::IpoptSolver( CasADi::IpoptSolver() );
}


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

    return new CasADi::IpoptSolver( CasADi::IpoptSolver(x0_, x1_) );
}


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

    return new CasADi::IpoptSolver( CasADi::IpoptSolver(x0_) );
}


// ================== delete CasadiClass SXMatrix===============
// classType: CasadiClass SXMatrix
extern "C"
    void delete_CasADi__Matrix_CasADi__SX_(CasADi::Matrix< CasADi::SX >* obj);
void delete_CasADi__Matrix_CasADi__SX_(CasADi::Matrix< CasADi::SX >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__Matrix_CasADi__SX__(std::vector<CasADi::Matrix< CasADi::SX >* >* obj);
void delete_std__vector_CasADi__Matrix_CasADi__SX__(std::vector<CasADi::Matrix< CasADi::SX >* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > >* obj);
void delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____(std::vector<std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____(std::vector<std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > >* obj){
    delete obj;
}

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

    return obj->size1();
}


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

    return obj->size2();
}


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

    return obj->size();
}


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

    return obj->numel();
}


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

    return obj->sanityCheck(x0_);
}


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

    return obj->sanityCheck();
}


// ================== Normal method: "vector" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::vector"
// cWrapperName: "CasADi__Matrix_CasADi__SX___vector"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_CasADi__SX___vector(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->vector()"
extern "C"
    bool* CasADi__Matrix_CasADi__SX___vector(CasADi::Matrix< CasADi::SX >* obj);
bool* CasADi__Matrix_CasADi__SX___vector(CasADi::Matrix< CasADi::SX >* obj){

    return new bool( obj->vector() );
}


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

    return new CasADi::SX( obj->at(x0_) );
}


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

    return new CasADi::SX( obj->elem(x0_, x1_) );
}


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

    return new CasADi::SX( obj->elem(x0_) );
}


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

    return new bool( obj->hasNZ(x0_, x1_) );
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__nonzero__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____nonzero__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_CasADi__SX_____nonzero__(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->__nonzero__()"
extern "C"
    bool* CasADi__Matrix_CasADi__SX_____nonzero__(CasADi::Matrix< CasADi::SX >* obj);
bool* CasADi__Matrix_CasADi__SX_____nonzero__(CasADi::Matrix< CasADi::SX >* obj){

    return new bool( obj->__nonzero__() );
}


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

    return obj->append(x0_);
}


// ================== Normal method: "operator +" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::operator +"
// cWrapperName: "CasADi__Matrix_CasADi__SX___operator_plus"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_plus(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->operator +()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_plus(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_plus(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->operator +() );
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::operator -"
// cWrapperName: "CasADi__Matrix_CasADi__SX___operator_minus"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_minus(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_minus(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_minus(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->operator -() );
}


// ================== Static method: "binary" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::binary"
// cWrapperName: "CasADi__Matrix_CasADi__SX___binary"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___binary(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::Matrix< CasADi::SX >::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___binary(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___binary(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::binary(x0_, x1_, x2_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::unary(x0_, x1_) );
}


// ================== Static method: "scalar_matrix" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::scalar_matrix"
// cWrapperName: "CasADi__Matrix_CasADi__SX___scalar_matrix"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___scalar_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::Matrix< CasADi::SX >::scalar_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___scalar_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___scalar_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::scalar_matrix(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_scalar" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::matrix_scalar"
// cWrapperName: "CasADi__Matrix_CasADi__SX___matrix_scalar"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_scalar(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::Matrix< CasADi::SX >::matrix_scalar(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_scalar(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_scalar(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::matrix_scalar(x0_, x1_, x2_) );
}


// ================== Static method: "matrix_matrix" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::matrix_matrix"
// cWrapperName: "CasADi__Matrix_CasADi__SX___matrix_matrix"
// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::Matrix< CasADi::SX >::matrix_matrix(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::matrix_matrix(x0_, x1_, x2_) );
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__add__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____add__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____add__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____add__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____add__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__sub__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____sub__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____sub__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____sub__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____sub__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__mul__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____mul__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mul__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mul__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mul__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__div__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____div__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____div__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____div__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____div__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__lt__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____lt__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____lt__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____lt__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____lt__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__le__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____le__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____le__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____le__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____le__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__eq__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____eq__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____eq__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____eq__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____eq__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__ne__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____ne__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____ne__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____ne__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____ne__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__truediv__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____truediv__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____truediv__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____truediv__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____truediv__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__pow__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____pow__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____pow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____pow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____pow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__constpow__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____constpow__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____constpow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____constpow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____constpow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__mpower__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____mpower__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mpower__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mpower__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mpower__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__mpower__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::__mrdivide__"
// cWrapperName: "CasADi__Matrix_CasADi__SX_____mrdivide__"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mrdivide__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mrdivide__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mrdivide__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "mul_full" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::mul_full"
// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_full"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( obj->mul_full(x0_, x1_) );
}


// ================== Normal method: "mul_full'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::mul_full'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_full_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->mul_full(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->mul_full(x0_) );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::mul"
// cWrapperName: "CasADi__Matrix_CasADi__SX___mul"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( obj->mul(x0_, x1_) );
}


// ================== Normal method: "mul'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::mul'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->mul(x0_) );
}


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

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


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

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


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

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


// ================== Static method: "mul_no_alloc_nn'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"
// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2);
void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);

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


// ================== Static method: "mul_no_alloc_tn'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"
// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn(x0_, x1_, x2_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2);
void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);

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


// ================== Static method: "quad_form" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::quad_form"
// cWrapperName: "CasADi__Matrix_CasADi__SX___quad_form"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1)"
// call: "CasADi::Matrix< CasADi::SX >::quad_form(x0_, x1_)"
extern "C"
    CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1);
CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);

    return new CasADi::SX( CasADi::Matrix< CasADi::SX >::quad_form(x0_, x1_) );
}


// ================== Normal method: "trans" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::trans"
// cWrapperName: "CasADi__Matrix_CasADi__SX___trans"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___trans(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___trans(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___trans(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->trans() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sin"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sin"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sin(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sin(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sin(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::cos"
// cWrapperName: "CasADi__Matrix_CasADi__SX___cos"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cos(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cos(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cos(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::tan"
// cWrapperName: "CasADi__Matrix_CasADi__SX___tan"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tan(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tan(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tan(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arcsin"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arcsin"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsin(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsin(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsin(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arccos"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arccos"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccos(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccos(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccos(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arctan"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arctan"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->arctan() );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::exp"
// cWrapperName: "CasADi__Matrix_CasADi__SX___exp"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___exp(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___exp(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___exp(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::log"
// cWrapperName: "CasADi__Matrix_CasADi__SX___log"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->log()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->log() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sqrt"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sqrt"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sqrt(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sqrt(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sqrt(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->sqrt() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::floor"
// cWrapperName: "CasADi__Matrix_CasADi__SX___floor"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___floor(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___floor(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___floor(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::ceil"
// cWrapperName: "CasADi__Matrix_CasADi__SX___ceil"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ceil(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ceil(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ceil(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->ceil() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::fabs"
// cWrapperName: "CasADi__Matrix_CasADi__SX___fabs"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fabs(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fabs(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fabs(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->fabs() );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sign"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sign"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sign(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sign(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sign(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->sign() );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::erfinv"
// cWrapperName: "CasADi__Matrix_CasADi__SX___erfinv"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erfinv(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erfinv(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erfinv(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->erfinv() );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::fmin"
// cWrapperName: "CasADi__Matrix_CasADi__SX___fmin"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmin(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmin(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmin(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::fmax"
// cWrapperName: "CasADi__Matrix_CasADi__SX___fmax"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmax(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmax(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmax(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->fmax(x0_) );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::erf"
// cWrapperName: "CasADi__Matrix_CasADi__SX___erf"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erf(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erf(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erf(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->erf() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sinh"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sinh"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sinh(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sinh(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sinh(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::cosh"
// cWrapperName: "CasADi__Matrix_CasADi__SX___cosh"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cosh(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cosh(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cosh(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::tanh"
// cWrapperName: "CasADi__Matrix_CasADi__SX___tanh"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tanh(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tanh(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tanh(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arcsinh"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arcsinh"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsinh(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsinh(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsinh(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arccosh"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arccosh"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccosh(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccosh(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccosh(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arctanh"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arctanh"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctanh(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctanh(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctanh(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->arctanh() );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::arctan2"
// cWrapperName: "CasADi__Matrix_CasADi__SX___arctan2"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan2(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan2(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan2(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->arctan2(x0_) );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::log10"
// cWrapperName: "CasADi__Matrix_CasADi__SX___log10"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log10(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log10(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log10(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->log10() );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::printme"
// cWrapperName: "CasADi__Matrix_CasADi__SX___printme"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___printme(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___printme(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___printme(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->printme(x0_) );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::logic_not"
// cWrapperName: "CasADi__Matrix_CasADi__SX___logic_not"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_not(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_not(CasADi::Matrix< CasADi::SX >* obj);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_not(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::Matrix< CasADi::SX >( obj->logic_not() );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::logic_and"
// cWrapperName: "CasADi__Matrix_CasADi__SX___logic_and"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_and(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_and(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_and(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::logic_or"
// cWrapperName: "CasADi__Matrix_CasADi__SX___logic_or"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_or(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_or(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_or(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::if_else_zero"
// cWrapperName: "CasADi__Matrix_CasADi__SX___if_else_zero"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___if_else_zero(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___if_else_zero(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___if_else_zero(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->if_else_zero(x0_) );
}


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

    return new std::string( CasADi::Matrix< CasADi::SX >::className() );
}


// ================== Normal method: "printScalar'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::printScalar'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___printScalar_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___printScalar_TIC(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->printScalar()"
extern "C"
    void CasADi__Matrix_CasADi__SX___printScalar_TIC(CasADi::Matrix< CasADi::SX >* obj);
void CasADi__Matrix_CasADi__SX___printScalar_TIC(CasADi::Matrix< CasADi::SX >* obj){

    return obj->printScalar();
}


// ================== Normal method: "printVector'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::printVector'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___printVector_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___printVector_TIC(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->printVector()"
extern "C"
    void CasADi__Matrix_CasADi__SX___printVector_TIC(CasADi::Matrix< CasADi::SX >* obj);
void CasADi__Matrix_CasADi__SX___printVector_TIC(CasADi::Matrix< CasADi::SX >* obj){

    return obj->printVector();
}


// ================== Normal method: "printMatrix'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::printMatrix'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___printMatrix_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___printMatrix_TIC(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->printMatrix()"
extern "C"
    void CasADi__Matrix_CasADi__SX___printMatrix_TIC(CasADi::Matrix< CasADi::SX >* obj);
void CasADi__Matrix_CasADi__SX___printMatrix_TIC(CasADi::Matrix< CasADi::SX >* obj){

    return obj->printMatrix();
}


// ================== Normal method: "printSparse'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::printSparse'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___printSparse_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___printSparse_TIC(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->printSparse()"
extern "C"
    void CasADi__Matrix_CasADi__SX___printSparse_TIC(CasADi::Matrix< CasADi::SX >* obj);
void CasADi__Matrix_CasADi__SX___printSparse_TIC(CasADi::Matrix< CasADi::SX >* obj){

    return obj->printSparse();
}


// ================== Normal method: "printDense'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::printDense'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___printDense_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___printDense_TIC(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->printDense()"
extern "C"
    void CasADi__Matrix_CasADi__SX___printDense_TIC(CasADi::Matrix< CasADi::SX >* obj);
void CasADi__Matrix_CasADi__SX___printDense_TIC(CasADi::Matrix< CasADi::SX >* obj){

    return obj->printDense();
}


// ================== Normal method: "col" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::col"
// cWrapperName: "CasADi__Matrix_CasADi__SX___col"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SX___col(CasADi::Matrix< CasADi::SX >* obj, int x0)"
// call: "obj->col(x0_)"
extern "C"
    int CasADi__Matrix_CasADi__SX___col(CasADi::Matrix< CasADi::SX >* obj, int x0);
int CasADi__Matrix_CasADi__SX___col(CasADi::Matrix< CasADi::SX >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return obj->col(x0_);
}


// ================== Normal method: "rowind" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::rowind"
// cWrapperName: "CasADi__Matrix_CasADi__SX___rowind"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__Matrix_CasADi__SX___rowind(CasADi::Matrix< CasADi::SX >* obj, int x0)"
// call: "obj->rowind(x0_)"
extern "C"
    int CasADi__Matrix_CasADi__SX___rowind(CasADi::Matrix< CasADi::SX >* obj, int x0);
int CasADi__Matrix_CasADi__SX___rowind(CasADi::Matrix< CasADi::SX >* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return obj->rowind(x0_);
}


// ================== Normal method: "clear" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::clear"
// cWrapperName: "CasADi__Matrix_CasADi__SX___clear"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___clear(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->clear()"
extern "C"
    void CasADi__Matrix_CasADi__SX___clear(CasADi::Matrix< CasADi::SX >* obj);
void CasADi__Matrix_CasADi__SX___clear(CasADi::Matrix< CasADi::SX >* obj){

    return obj->clear();
}


// ================== Normal method: "resize" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::resize"
// cWrapperName: "CasADi__Matrix_CasADi__SX___resize"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___resize(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"
// call: "obj->resize(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___resize(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1);
void CasADi__Matrix_CasADi__SX___resize(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return obj->resize(x0_, x1_);
}


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

    return obj->reserve(x0_);
}


// ================== Normal method: "reserve'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::reserve'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___reserve_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___reserve_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"
// call: "obj->reserve(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___reserve_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1);
void CasADi__Matrix_CasADi__SX___reserve_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return obj->reserve(x0_, x1_);
}


// ================== Normal method: "erase" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::erase"
// cWrapperName: "CasADi__Matrix_CasADi__SX___erase"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"
// call: "obj->erase(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1);
void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* 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 obj->erase(x0_, x1_);
}


// ================== Normal method: "remove" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::remove"
// cWrapperName: "CasADi__Matrix_CasADi__SX___remove"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"
// call: "obj->remove(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1);
void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* 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 obj->remove(x0_, x1_);
}


// ================== Normal method: "enlarge" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::enlarge"
// cWrapperName: "CasADi__Matrix_CasADi__SX___enlarge"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___enlarge(CasADi::Matrix< CasADi::SX >* 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__SX___enlarge(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);
void CasADi__Matrix_CasADi__SX___enlarge(CasADi::Matrix< CasADi::SX >* 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 obj->enlarge(x0_, x1_, x2_, x3_);
}


// ================== Normal method: "data" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::data"
// cWrapperName: "CasADi__Matrix_CasADi__SX___data"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (Vec (NonVec (CasadiClass SX)))
// cWrapperRetType: "std::vector<CasADi::SX >*"
// proto: "std::vector<CasADi::SX >* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->data()"
extern "C"
    std::vector<CasADi::SX >* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj);
std::vector<CasADi::SX >* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj){

    return new std::vector<CasADi::SX >( obj->data() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sparsityRef"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sparsityRef"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__Matrix_CasADi__SX___sparsityRef(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::CRSSparsity* CasADi__Matrix_CasADi__SX___sparsityRef(CasADi::Matrix< CasADi::SX >* obj);
CasADi::CRSSparsity* CasADi__Matrix_CasADi__SX___sparsityRef(CasADi::Matrix< CasADi::SX >* obj){

    return new CasADi::CRSSparsity( obj->sparsityRef() );
}


// ================== Normal method: "set" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::set"
// cWrapperName: "CasADi__Matrix_CasADi__SX___set"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___set(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___set(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1);
void CasADi__Matrix_CasADi__SX___set(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return obj->set(x0_, x1_);
}


// ================== Normal method: "set'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::set'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___set_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___set_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0);
void CasADi__Matrix_CasADi__SX___set_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return obj->set(x0_);
}


// ================== Normal method: "get" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::get"
// cWrapperName: "CasADi__Matrix_CasADi__SX___get"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___get(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___get(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1);
void CasADi__Matrix_CasADi__SX___get(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return obj->get(x0_, x1_);
}


// ================== Normal method: "get'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::get'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___get_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___get_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0);
void CasADi__Matrix_CasADi__SX___get_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return obj->get(x0_);
}


// ================== Normal method: "set''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::set''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1);
void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return obj->set(x0_, x1_);
}


// ================== Normal method: "set'''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::set'''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0);
void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);

    return obj->set(x0_);
}


// ================== Normal method: "get''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::get''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1);
void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return obj->get(x0_, x1_);
}


// ================== Normal method: "get'''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::get'''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0);
void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);

    return obj->get(x0_);
}


// ================== Normal method: "set''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::set''''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1);
void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return obj->set(x0_, x1_);
}


// ================== Normal method: "set'''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::set'''''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->set(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return obj->set(x0_);
}


// ================== Normal method: "get''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::get''''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1);
void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return obj->get(x0_, x1_);
}


// ================== Normal method: "get'''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::get'''''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->get(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);
void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return obj->get(x0_);
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_) );
}


// ================== Static method: "sparse''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sparse''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC"
// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2)"
// call: "CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * 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::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_) );
}


// ================== Static method: "sparse'''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::sparse'''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC"
// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4)"
// call: "CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * 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::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::zeros"
// cWrapperName: "CasADi__Matrix_CasADi__SX___zeros"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< CasADi::SX >::zeros(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros(CasADi::CRSSparsity* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::zeros(x0_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::zeros(x0_, x1_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::ones"
// cWrapperName: "CasADi__Matrix_CasADi__SX___ones"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< CasADi::SX >::ones(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones(CasADi::CRSSparsity* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::ones(x0_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::ones(x0_, x1_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::ones(x0_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::inf"
// cWrapperName: "CasADi__Matrix_CasADi__SX___inf"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< CasADi::SX >::inf(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf(CasADi::CRSSparsity* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf(x0_) );
}


// ================== Static method: "inf'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::inf'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___inf_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC(int x0, int x1)"
// call: "CasADi::Matrix< CasADi::SX >::inf(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC(int x0, int x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf(x0_, x1_) );
}


// ================== Static method: "inf''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::inf''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___inf_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC(int x0)"
// call: "CasADi::Matrix< CasADi::SX >::inf(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC(int x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf(x0_) );
}


// ================== Static method: "inf'''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::inf'''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC()"
// call: "CasADi::Matrix< CasADi::SX >::inf()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC();
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC(){

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::nan"
// cWrapperName: "CasADi__Matrix_CasADi__SX___nan"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< CasADi::SX >::nan(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan(CasADi::CRSSparsity* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan(x0_) );
}


// ================== Static method: "nan'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::nan'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___nan_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC(int x0, int x1)"
// call: "CasADi::Matrix< CasADi::SX >::nan(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC(int x0, int x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan(x0_, x1_) );
}


// ================== Static method: "nan''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::nan''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___nan_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC(int x0)"
// call: "CasADi::Matrix< CasADi::SX >::nan(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC(int x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan(x0_) );
}


// ================== Static method: "nan'''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::nan'''"
// cWrapperName: "CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC()"
// call: "CasADi::Matrix< CasADi::SX >::nan()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC();
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC(){

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::repmat"
// cWrapperName: "CasADi__Matrix_CasADi__SX___repmat"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_, x2_) );
}


// ================== Static method: "repmat'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::repmat'"
// cWrapperName: "CasADi__Matrix_CasADi__SX___repmat_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_) );
}


// ================== Static method: "eye" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::eye"
// cWrapperName: "CasADi__Matrix_CasADi__SX___eye"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___eye(int x0)"
// call: "CasADi::Matrix< CasADi::SX >::eye(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___eye(int x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___eye(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::eye(x0_) );
}


// ================== Normal method: "isNull" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::isNull"
// cWrapperName: "CasADi__Matrix_CasADi__SX___isNull"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_CasADi__SX___isNull(CasADi::Matrix< CasADi::SX >* obj)"
// call: "obj->isNull()"
extern "C"
    bool* CasADi__Matrix_CasADi__SX___isNull(CasADi::Matrix< CasADi::SX >* obj);
bool* CasADi__Matrix_CasADi__SX___isNull(CasADi::Matrix< CasADi::SX >* obj){

    return new bool( obj->isNull() );
}


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

    return CasADi::Matrix< CasADi::SX >::setPrecision(x0_);
}


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

    return CasADi::Matrix< CasADi::SX >::setWidth(x0_);
}


// ================== Static method: "setScientific" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >::setScientific"
// cWrapperName: "CasADi__Matrix_CasADi__SX___setScientific"
// protoArgs: "(bool* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_CasADi__SX___setScientific(bool* x0)"
// call: "CasADi::Matrix< CasADi::SX >::setScientific(x0_)"
extern "C"
    void CasADi__Matrix_CasADi__SX___setScientific(bool* x0);
void CasADi__Matrix_CasADi__SX___setScientific(bool* x0){
    bool x0_ = Marshaling<bool,bool*>::marshal(x0);

    return CasADi::Matrix< CasADi::SX >::setScientific(x0_);
}


// ================== Constructor method: "SXMatrix" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix()"
// call: "CasADi::Matrix< CasADi::SX >()"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix();
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix(){

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >() );
}


// ================== Constructor method: "SXMatrix'" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::Matrix< CasADi::SX >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );
}


// ================== Constructor method: "SXMatrix''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC(int x0, int x1)"
// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC(int x0, int x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_) );
}


// ================== Constructor method: "SXMatrix'''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1, CasADi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC(int x0, int x1, CasADi::SX* x2)"
// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC(int x0, int x1, CasADi::SX* x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC(int x0, int x1, CasADi::SX* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    CasADi::SX x2_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_) );
}


// ================== Constructor method: "SXMatrix''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4)"
// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * 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<CasADi::SX > x4_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x4);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Constructor method: "SXMatrix'''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_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 new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "SXMatrix''''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<std::vector<CasADi::SX* > > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<CasADi::SX* > > * x0)"
// call: "CasADi::Matrix< CasADi::SX >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<CasADi::SX* > > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<CasADi::SX* > > * x0){
    std::vector<std::vector<CasADi::SX > > x0_ = Marshaling<std::vector<std::vector<CasADi::SX > >,std::vector<std::vector<CasADi::SX* > > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );
}


// ================== Constructor method: "SXMatrix'''''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0, CasADi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::SX* x1)"
// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::SX* x1);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::SX* x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_) );
}


// ================== Constructor method: "SXMatrix''''''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< CasADi::SX >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_) );
}


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

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );
}


// ================== Constructor method: "SXMatrix'''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::SX* > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0)"
// call: "CasADi::Matrix< CasADi::SX >(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );
}


// ================== Constructor method: "SXMatrix''''''''''''" ===============
// class: "CasADi::Matrix< CasADi::SX >"
// cppName: "CasADi::Matrix< CasADi::SX >"
// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::SX* > * x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0, int x1, int x2)"
// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0, int x1, int x2);
CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0, int x1, int x2){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_) );
}


// ================== delete CasadiClass IOScheme===============
// classType: CasadiClass IOScheme
extern "C"
    void delete_CasADi__IOScheme(CasADi::IOScheme* obj);
void delete_CasADi__IOScheme(CasADi::IOScheme* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__IOScheme_(std::vector<CasADi::IOScheme* >* obj);
void delete_std__vector_CasADi__IOScheme_(std::vector<CasADi::IOScheme* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__IOScheme__(std::vector<std::vector<CasADi::IOScheme* > >* obj);
void delete_std__vector_std__vector_CasADi__IOScheme__(std::vector<std::vector<CasADi::IOScheme* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__IOScheme___(std::vector<std::vector<std::vector<CasADi::IOScheme* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__IOScheme___(std::vector<std::vector<std::vector<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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__IOScheme__checkNode(CasADi::IOScheme* obj)"
// call: "obj->checkNode()"
extern "C"
    bool* CasADi__IOScheme__checkNode(CasADi::IOScheme* obj);
bool* CasADi__IOScheme__checkNode(CasADi::IOScheme* obj){

    return new bool( obj->checkNode() );
}


// ================== Normal method: "name" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::name"
// cWrapperName: "CasADi__IOScheme__name"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: Val (NonVec 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 new std::string( obj->name() );
}


// ================== Normal method: "entryNames" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::entryNames"
// cWrapperName: "CasADi__IOScheme__entryNames"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: Val (NonVec 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 new std::string( 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: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return obj->index(x0_);
}


// ================== Normal method: "size" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::size"
// cWrapperName: "CasADi__IOScheme__size"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec 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 new std::string( 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: Val (NonVec 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 new std::string( 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: Val (NonVec 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 new std::string( 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: Val (NonVec 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 new std::string( 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: Val (NonVec 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 new std::string( 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: Val (NonVec 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 new std::string( obj->describe(x0_) );
}


// ================== Normal method: "known" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme::known"
// cWrapperName: "CasADi__IOScheme__known"
// protoArgs: "(CasADi::IOScheme* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__IOScheme__known(CasADi::IOScheme* obj)"
// call: "obj->known()"
extern "C"
    bool* CasADi__IOScheme__known(CasADi::IOScheme* obj);
bool* CasADi__IOScheme__known(CasADi::IOScheme* obj){

    return new bool( 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: Val (NonVec 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 obj->compatibleSize(x0_);
}


// ================== Constructor method: "IOScheme" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::IOScheme( CasADi::IOScheme() );
}


// ================== Constructor method: "IOScheme'" ===============
// class: "CasADi::IOScheme"
// cppName: "CasADi::IOScheme"
// cWrapperName: "CasADi__IOScheme__IOScheme_TIC"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// args: "(x0_)"
// rettype: Val (NonVec (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 new CasADi::IOScheme( CasADi::IOScheme(x0_) );
}


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

    return new CasADi::IOScheme( CasADi::IOScheme(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;
}
extern "C"
    void delete_std__vector_CasADi__Matrix_double__(std::vector<CasADi::Matrix< double >* >* obj);
void delete_std__vector_CasADi__Matrix_double__(std::vector<CasADi::Matrix< double >* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__Matrix_double___(std::vector<std::vector<CasADi::Matrix< double >* > >* obj);
void delete_std__vector_std__vector_CasADi__Matrix_double___(std::vector<std::vector<CasADi::Matrix< double >* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____(std::vector<std::vector<std::vector<CasADi::Matrix< double >* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____(std::vector<std::vector<std::vector<CasADi::Matrix< double >* > > >* obj){
    delete obj;
}

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

    return obj->size1();
}


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

    return obj->size2();
}


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

    return obj->size();
}


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

    return obj->numel();
}


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

    return 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: Val (NonVec 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){

    return obj->sanityCheck();
}


// ================== Normal method: "vector" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::vector"
// cWrapperName: "CasADi__Matrix_double___vector"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_double___vector(CasADi::Matrix< double >* obj)"
// call: "obj->vector()"
extern "C"
    bool* CasADi__Matrix_double___vector(CasADi::Matrix< double >* obj);
bool* CasADi__Matrix_double___vector(CasADi::Matrix< double >* obj){

    return new bool( obj->vector() );
}


// ================== 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: Val (NonVec 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 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: Val (NonVec 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 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: Val (NonVec 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 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1)"
// call: "obj->hasNZ(x0_, x1_)"
extern "C"
    bool* CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1);
bool* 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 new bool( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj)"
// call: "obj->__nonzero__()"
extern "C"
    bool* CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj);
bool* CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj){

    return new bool( obj->__nonzero__() );
}


// ================== 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: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return obj->append(x0_);
}


// ================== 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* 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::CRSSparsity* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return CasADi::Matrix< double >::mul_no_alloc_nn(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: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return 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"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return 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: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return 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_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return CasADi::Matrix< double >::mul_no_alloc_tn(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: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);

    return 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( obj->sign() );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::erfinv"
// cWrapperName: "CasADi__Matrix_double___erfinv"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( obj->if_else_zero(x0_) );
}


// ================== Static method: "className" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::className"
// cWrapperName: "CasADi__Matrix_double___className"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( 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: Val (NonVec 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){

    return 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: Val (NonVec 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){

    return obj->printVector();
}


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

    return obj->printMatrix();
}


// ================== 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: Val (NonVec 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){

    return obj->printSparse();
}


// ================== 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: Val (NonVec 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){

    return obj->printDense();
}


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

    return obj->col(x0_);
}


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

    return obj->rowind(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: Val (NonVec 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){

    return 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: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return 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: Val (Vec (NonVec 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 new std::vector<double >( 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: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::CRSSparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj);
CasADi::CRSSparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj){

    return new CasADi::CRSSparsity( 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::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1);
void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1){
    double x0_ = Marshaling<double,double>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return 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: Val (NonVec 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);

    return 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::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1);
void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1){
    double x0_ = Marshaling<double,double*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return 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: Val (NonVec 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);

    return 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::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1)"
// call: "obj->set(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1);
void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return 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: Val (NonVec 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);

    return 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::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1)"
// call: "obj->get(x0_, x1_)"
extern "C"
    void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1);
void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return 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: Val (NonVec 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);

    return 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::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity 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::Sparsity x1);
void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return 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: Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return 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::Sparsity x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity 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::Sparsity x1);
void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);

    return 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: Val (NonVec 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);

    return obj->get(x0_);
}


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

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sparse'"
// cWrapperName: "CasADi__Matrix_double___sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC(int x0)"
// call: "CasADi::Matrix< double >::sparse(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC(int x0);
CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_) );
}


// ================== Static method: "sparse''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sparse''"
// cWrapperName: "CasADi__Matrix_double___sparse_TIC_TIC"
// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2)"
// call: "CasADi::Matrix< double >::sparse(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2);
CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(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 new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_, x1_, x2_) );
}


// ================== Static method: "sparse'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::sparse'''"
// cWrapperName: "CasADi__Matrix_double___sparse_TIC_TIC_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: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2, int x3, int x4)"
// call: "CasADi::Matrix< double >::sparse(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2, int x3, int x4);
CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_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 new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::zeros"
// cWrapperName: "CasADi__Matrix_double___zeros"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___zeros(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< double >::zeros(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___zeros(CasADi::CRSSparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___zeros(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::zeros(x0_) );
}


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

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::zeros(x0_, x1_) );
}


// ================== Static method: "zeros''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::zeros''"
// cWrapperName: "CasADi__Matrix_double___zeros_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC_TIC(int x0)"
// call: "CasADi::Matrix< double >::zeros(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC_TIC(int x0);
CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::ones"
// cWrapperName: "CasADi__Matrix_double___ones"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ones(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< double >::ones(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___ones(CasADi::CRSSparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___ones(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::ones(x0_) );
}


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

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::ones(x0_, x1_) );
}


// ================== Static method: "ones''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::ones''"
// cWrapperName: "CasADi__Matrix_double___ones_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC_TIC(int x0)"
// call: "CasADi::Matrix< double >::ones(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC_TIC(int x0);
CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >::ones(x0_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::inf"
// cWrapperName: "CasADi__Matrix_double___inf"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< double >::inf(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::CRSSparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( CasADi::Matrix< double >::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::nan"
// cWrapperName: "CasADi__Matrix_double___nan"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< double >::nan(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::CRSSparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( CasADi::Matrix< double >::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::repmat"
// cWrapperName: "CasADi__Matrix_double___repmat"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat(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(CasADi::Matrix< double >* x0, int x1, int x2);
CasADi::Matrix< double >* CasADi__Matrix_double___repmat(CasADi::Matrix< double >* x0, int x1, int x2){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< double >( 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"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, int x1)"
// call: "CasADi::Matrix< double >::repmat(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, int x1);
CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, int x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< double >( 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: Val (NonVec (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 new CasADi::Matrix< double >( CasADi::Matrix< double >::eye(x0_) );
}


// ================== Normal method: "isNull" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::isNull"
// cWrapperName: "CasADi__Matrix_double___isNull"
// protoArgs: "(CasADi::Matrix< double >* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__Matrix_double___isNull(CasADi::Matrix< double >* obj)"
// call: "obj->isNull()"
extern "C"
    bool* CasADi__Matrix_double___isNull(CasADi::Matrix< double >* obj);
bool* CasADi__Matrix_double___isNull(CasADi::Matrix< double >* obj){

    return new bool( obj->isNull() );
}


// ================== Static method: "setPrecision" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setPrecision"
// cWrapperName: "CasADi__Matrix_double___setPrecision"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return CasADi::Matrix< double >::setWidth(x0_);
}


// ================== Static method: "setScientific" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >::setScientific"
// cWrapperName: "CasADi__Matrix_double___setScientific"
// protoArgs: "(bool* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__Matrix_double___setScientific(bool* x0)"
// call: "CasADi::Matrix< double >::setScientific(x0_)"
extern "C"
    void CasADi__Matrix_double___setScientific(bool* x0);
void CasADi__Matrix_double___setScientific(bool* x0){
    bool x0_ = Marshaling<bool,bool*>::marshal(x0);

    return CasADi::Matrix< double >::setScientific(x0_);
}


// ================== Constructor method: "DMatrix" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::Matrix< double >( 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: Val (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_) );
}


// ================== Constructor method: "DMatrix''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(int x0, int x1)"
// call: "CasADi::Matrix< double >(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(int x0, int x1);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_) );
}


// ================== Constructor method: "DMatrix'''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1, double* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(int x0, int x1, double* x2)"
// call: "CasADi::Matrix< double >(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(int x0, int x1, double* x2);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(int x0, int x1, double* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    double x2_ = Marshaling<double,double*>::marshal(x2);

    return new CasADi::Matrix< double >( 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"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4)"
// args: "(x0_, x1_, x2_, x3_, x4_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4)"
// call: "CasADi::Matrix< double >(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * 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<double > x4_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x4);

    return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_, x3_, x4_) );
}


// ================== Constructor method: "DMatrix'''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// args: "(x0_, x1_, x2_, x3_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// call: "CasADi::Matrix< double >(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_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 new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_, x3_) );
}


// ================== Constructor method: "DMatrix''''''" ===============
// class: "CasADi::Matrix< double >"
// cppName: "CasADi::Matrix< double >"
// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<std::vector<double > > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<double > > * x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<double > > * x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_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 new CasADi::Matrix< double >( 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: "(CasADi::CRSSparsity* x0, double* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, double* x1)"
// call: "CasADi::Matrix< double >(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, double* x1);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, double* x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    double x1_ = Marshaling<double,double*>::marshal(x1);

    return new CasADi::Matrix< double >( 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_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"
// call: "CasADi::Matrix< double >(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::Matrix< double >( 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"
// protoArgs: "(CasADi::CRSSparsity* x0, std::vector<double > * x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* 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_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<double > * x1);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<double > * x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);

    return new CasADi::Matrix< double >( 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_TIC_TIC_TIC_TIC"
// protoArgs: "(double x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass DMatrix))
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_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_TIC_TIC_TIC_TIC(double x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0){
    double x0_ = Marshaling<double,double>::marshal(x0);

    return new CasADi::Matrix< double >( 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<double > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec (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<double > * 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_TIC(std::vector<double > * x0);
CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_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 new CasADi::Matrix< double >( 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_TIC"
// protoArgs: "(std::vector<double > * x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (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_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_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_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 new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_) );
}


// ================== delete CasadiClass MX===============
// classType: CasadiClass MX
extern "C"
    void delete_CasADi__MX(CasADi::MX* obj);
void delete_CasADi__MX(CasADi::MX* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__MX_(std::vector<CasADi::MX* >* obj);
void delete_std__vector_CasADi__MX_(std::vector<CasADi::MX* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__MX__(std::vector<std::vector<CasADi::MX* > >* obj);
void delete_std__vector_std__vector_CasADi__MX__(std::vector<std::vector<CasADi::MX* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__MX___(std::vector<std::vector<std::vector<CasADi::MX* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__MX___(std::vector<std::vector<std::vector<CasADi::MX* > > >* obj){
    delete obj;
}

// ================== Normal method: "size1" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::size1"
// cWrapperName: "CasADi__MX__size1"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__MX__size1(CasADi::MX* obj)"
// call: "obj->size1()"
extern "C"
    int CasADi__MX__size1(CasADi::MX* obj);
int CasADi__MX__size1(CasADi::MX* obj){

    return obj->size1();
}


// ================== Normal method: "size2" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::size2"
// cWrapperName: "CasADi__MX__size2"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__MX__size2(CasADi::MX* obj)"
// call: "obj->size2()"
extern "C"
    int CasADi__MX__size2(CasADi::MX* obj);
int CasADi__MX__size2(CasADi::MX* obj){

    return obj->size2();
}


// ================== Normal method: "size" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::size"
// cWrapperName: "CasADi__MX__size"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__MX__size(CasADi::MX* obj)"
// call: "obj->size()"
extern "C"
    int CasADi__MX__size(CasADi::MX* obj);
int CasADi__MX__size(CasADi::MX* obj){

    return obj->size();
}


// ================== Normal method: "numel" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::numel"
// cWrapperName: "CasADi__MX__numel"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__MX__numel(CasADi::MX* obj)"
// call: "obj->numel()"
extern "C"
    int CasADi__MX__numel(CasADi::MX* obj);
int CasADi__MX__numel(CasADi::MX* obj){

    return obj->numel();
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__nonzero__"
// cWrapperName: "CasADi__MX____nonzero__"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX____nonzero__(CasADi::MX* obj)"
// call: "obj->__nonzero__()"
extern "C"
    bool* CasADi__MX____nonzero__(CasADi::MX* obj);
bool* CasADi__MX____nonzero__(CasADi::MX* obj){

    return new bool( obj->__nonzero__() );
}


// ================== Normal method: "sparsityRef" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sparsityRef"
// cWrapperName: "CasADi__MX__sparsityRef"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass CRSSparsity))
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__MX__sparsityRef(CasADi::MX* obj)"
// call: "obj->sparsityRef()"
extern "C"
    CasADi::CRSSparsity* CasADi__MX__sparsityRef(CasADi::MX* obj);
CasADi::CRSSparsity* CasADi__MX__sparsityRef(CasADi::MX* obj){

    return new CasADi::CRSSparsity( 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: Val (NonVec 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);

    return 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: Val (NonVec 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);

    return 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: Val (NonVec (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 new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( obj->getDep(x0_) );
}


// ================== Normal method: "getDep'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getDep'"
// cWrapperName: "CasADi__MX__getDep_TIC"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->getDep() );
}


// ================== Normal method: "getNumOutputs" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNumOutputs"
// cWrapperName: "CasADi__MX__getNumOutputs"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec (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 new CasADi::MX( obj->getOutput(x0_) );
}


// ================== Normal method: "getOutput'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getOutput'"
// cWrapperName: "CasADi__MX__getOutput_TIC"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->getOutput() );
}


// ================== Normal method: "getNdeps" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNdeps"
// cWrapperName: "CasADi__MX__getNdeps"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->getNdeps();
}


// ================== Normal method: "getName" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getName"
// cWrapperName: "CasADi__MX__getName"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 new std::string( obj->getName() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getValue"
// cWrapperName: "CasADi__MX__getValue"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->getValue();
}


// ================== Normal method: "getMatrixValue" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getMatrixValue"
// cWrapperName: "CasADi__MX__getMatrixValue"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::Matrix< double >( obj->getMatrixValue() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isSymbolic"
// cWrapperName: "CasADi__MX__isSymbolic"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isSymbolic(CasADi::MX* obj)"
// call: "obj->isSymbolic()"
extern "C"
    bool* CasADi__MX__isSymbolic(CasADi::MX* obj);
bool* CasADi__MX__isSymbolic(CasADi::MX* obj){

    return new bool( obj->isSymbolic() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isConstant"
// cWrapperName: "CasADi__MX__isConstant"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isConstant(CasADi::MX* obj)"
// call: "obj->isConstant()"
extern "C"
    bool* CasADi__MX__isConstant(CasADi::MX* obj);
bool* CasADi__MX__isConstant(CasADi::MX* obj){

    return new bool( obj->isConstant() );
}


// ================== Normal method: "isEvaluation" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isEvaluation"
// cWrapperName: "CasADi__MX__isEvaluation"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isEvaluation(CasADi::MX* obj)"
// call: "obj->isEvaluation()"
extern "C"
    bool* CasADi__MX__isEvaluation(CasADi::MX* obj);
bool* CasADi__MX__isEvaluation(CasADi::MX* obj){

    return new bool( obj->isEvaluation() );
}


// ================== Normal method: "isEvaluationOutput" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isEvaluationOutput"
// cWrapperName: "CasADi__MX__isEvaluationOutput"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isEvaluationOutput(CasADi::MX* obj)"
// call: "obj->isEvaluationOutput()"
extern "C"
    bool* CasADi__MX__isEvaluationOutput(CasADi::MX* obj);
bool* CasADi__MX__isEvaluationOutput(CasADi::MX* obj){

    return new bool( obj->isEvaluationOutput() );
}


// ================== Normal method: "getEvaluationOutput" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getEvaluationOutput"
// cWrapperName: "CasADi__MX__getEvaluationOutput"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isOperation(CasADi::MX* obj, int x0)"
// call: "obj->isOperation(x0_)"
extern "C"
    bool* CasADi__MX__isOperation(CasADi::MX* obj, int x0);
bool* CasADi__MX__isOperation(CasADi::MX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new bool( obj->isOperation(x0_) );
}


// ================== Normal method: "isMultiplication" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isMultiplication"
// cWrapperName: "CasADi__MX__isMultiplication"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isMultiplication(CasADi::MX* obj)"
// call: "obj->isMultiplication()"
extern "C"
    bool* CasADi__MX__isMultiplication(CasADi::MX* obj);
bool* CasADi__MX__isMultiplication(CasADi::MX* obj){

    return new bool( obj->isMultiplication() );
}


// ================== Normal method: "isCommutative" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isCommutative"
// cWrapperName: "CasADi__MX__isCommutative"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isCommutative(CasADi::MX* obj)"
// call: "obj->isCommutative()"
extern "C"
    bool* CasADi__MX__isCommutative(CasADi::MX* obj);
bool* CasADi__MX__isCommutative(CasADi::MX* obj){

    return new bool( obj->isCommutative() );
}


// ================== Normal method: "isNorm" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isNorm"
// cWrapperName: "CasADi__MX__isNorm"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isNorm(CasADi::MX* obj)"
// call: "obj->isNorm()"
extern "C"
    bool* CasADi__MX__isNorm(CasADi::MX* obj);
bool* CasADi__MX__isNorm(CasADi::MX* obj){

    return new bool( obj->isNorm() );
}


// ================== Normal method: "getFunction" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getFunction"
// cWrapperName: "CasADi__MX__getFunction"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass FX))
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__MX__getFunction(CasADi::MX* obj)"
// call: "obj->getFunction()"
extern "C"
    CasADi::FX* CasADi__MX__getFunction(CasADi::MX* obj);
CasADi::FX* CasADi__MX__getFunction(CasADi::MX* obj){

    return new CasADi::FX( obj->getFunction() );
}


// ================== Normal method: "isBinary" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isBinary"
// cWrapperName: "CasADi__MX__isBinary"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isBinary(CasADi::MX* obj)"
// call: "obj->isBinary()"
extern "C"
    bool* CasADi__MX__isBinary(CasADi::MX* obj);
bool* CasADi__MX__isBinary(CasADi::MX* obj){

    return new bool( obj->isBinary() );
}


// ================== Normal method: "isUnary" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::isUnary"
// cWrapperName: "CasADi__MX__isUnary"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isUnary(CasADi::MX* obj)"
// call: "obj->isUnary()"
extern "C"
    bool* CasADi__MX__isUnary(CasADi::MX* obj);
bool* CasADi__MX__isUnary(CasADi::MX* obj){

    return new bool( obj->isUnary() );
}


// ================== Normal method: "getOp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getOp"
// cWrapperName: "CasADi__MX__getOp"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1)"
// call: "obj->isEqual(x0_, x1_)"
extern "C"
    bool* CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1);
bool* CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new bool( 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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    bool* CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0);
bool* CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( obj->isEqual(x0_) );
}


// ================== Normal method: "__hash__" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::__hash__"
// cWrapperName: "CasADi__MX____hash__"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 obj->__hash__();
}


// ================== Normal method: "getTemp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getTemp"
// cWrapperName: "CasADi__MX__getTemp"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec 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 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: Val (NonVec 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);

    return 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: Val (NonVec (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 x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);
    CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);

    return new CasADi::MX( 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: Val (NonVec (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 x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::MX::unary(x0_, x1_) );
}


// ================== Static method: "sparse" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sparse"
// cWrapperName: "CasADi__MX__sparse"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__sparse(int x0, int x1)"
// call: "CasADi::MX::sparse(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__sparse(int x0, int x1);
CasADi::MX* CasADi__MX__sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::MX( CasADi::MX::sparse(x0_, x1_) );
}


// ================== Static method: "sparse'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sparse'"
// cWrapperName: "CasADi__MX__sparse_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__sparse_TIC(int x0)"
// call: "CasADi::MX::sparse(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__sparse_TIC(int x0);
CasADi::MX* CasADi__MX__sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::MX( CasADi::MX::sparse(x0_) );
}


// ================== Static method: "zeros" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::zeros"
// cWrapperName: "CasADi__MX__zeros"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__zeros(CasADi::CRSSparsity* x0)"
// call: "CasADi::MX::zeros(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__zeros(CasADi::CRSSparsity* x0);
CasADi::MX* CasADi__MX__zeros(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::MX( CasADi::MX::zeros(x0_) );
}


// ================== Static method: "zeros'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::zeros'"
// cWrapperName: "CasADi__MX__zeros_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__zeros_TIC(int x0, int x1)"
// call: "CasADi::MX::zeros(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__zeros_TIC(int x0, int x1);
CasADi::MX* CasADi__MX__zeros_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::MX( CasADi::MX::zeros(x0_, x1_) );
}


// ================== Static method: "zeros''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::zeros''"
// cWrapperName: "CasADi__MX__zeros_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__zeros_TIC_TIC(int x0)"
// call: "CasADi::MX::zeros(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__zeros_TIC_TIC(int x0);
CasADi::MX* CasADi__MX__zeros_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::MX( CasADi::MX::zeros(x0_) );
}


// ================== Static method: "ones" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::ones"
// cWrapperName: "CasADi__MX__ones"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__ones(CasADi::CRSSparsity* x0)"
// call: "CasADi::MX::ones(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__ones(CasADi::CRSSparsity* x0);
CasADi::MX* CasADi__MX__ones(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::MX( CasADi::MX::ones(x0_) );
}


// ================== Static method: "ones'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::ones'"
// cWrapperName: "CasADi__MX__ones_TIC"
// protoArgs: "(int x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__ones_TIC(int x0, int x1)"
// call: "CasADi::MX::ones(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__ones_TIC(int x0, int x1);
CasADi::MX* CasADi__MX__ones_TIC(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::MX( CasADi::MX::ones(x0_, x1_) );
}


// ================== Static method: "ones''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::ones''"
// cWrapperName: "CasADi__MX__ones_TIC_TIC"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__ones_TIC_TIC(int x0)"
// call: "CasADi::MX::ones(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__ones_TIC_TIC(int x0);
CasADi::MX* CasADi__MX__ones_TIC_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::MX( CasADi::MX::ones(x0_) );
}


// ================== Static method: "inf" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inf"
// cWrapperName: "CasADi__MX__inf"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__inf(CasADi::CRSSparsity* x0)"
// call: "CasADi::MX::inf(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__inf(CasADi::CRSSparsity* x0);
CasADi::MX* CasADi__MX__inf(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( CasADi::MX::inf(x0_) );
}


// ================== Static method: "inf'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::inf'''"
// cWrapperName: "CasADi__MX__inf_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( CasADi::MX::inf() );
}


// ================== Static method: "nan" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nan"
// cWrapperName: "CasADi__MX__nan"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__nan(CasADi::CRSSparsity* x0)"
// call: "CasADi::MX::nan(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__nan(CasADi::CRSSparsity* x0);
CasADi::MX* CasADi__MX__nan(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( CasADi::MX::nan(x0_) );
}


// ================== Static method: "nan'''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::nan'''"
// cWrapperName: "CasADi__MX__nan_TIC_TIC_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( CasADi::MX::nan() );
}


// ================== Static method: "repmat" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::repmat"
// cWrapperName: "CasADi__MX__repmat"
// protoArgs: "(CasADi::MX* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, int x1, int x2)"
// call: "CasADi::MX::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, int x1, int x2);
CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, int x1, int x2){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::MX( CasADi::MX::repmat(x0_, x1_, x2_) );
}


// ================== Static method: "repmat'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::repmat'"
// cWrapperName: "CasADi__MX__repmat_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1)"
// call: "CasADi::MX::repmat(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1);
CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( CasADi::MX::eye(x0_) );
}


// ================== Normal method: "getNZ" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getNZ"
// cWrapperName: "CasADi__MX__getNZ"
// protoArgs: "(CasADi::MX* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (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 new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( obj->getNZ(x0_) );
}


// ================== Normal method: "append" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::append"
// cWrapperName: "CasADi__MX__append"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return obj->append(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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1)"
// call: "obj->mul(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1);
CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1)"
// call: "obj->mul_full(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1);
CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( obj->if_else_zero(x0_) );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::exp"
// cWrapperName: "CasADi__MX__exp"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::log"
// cWrapperName: "CasADi__MX__log"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->log() );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::log10"
// cWrapperName: "CasADi__MX__log10"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->log10() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sqrt"
// cWrapperName: "CasADi__MX__sqrt"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->sqrt() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sin"
// cWrapperName: "CasADi__MX__sin"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::cos"
// cWrapperName: "CasADi__MX__cos"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::tan"
// cWrapperName: "CasADi__MX__tan"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arcsin"
// cWrapperName: "CasADi__MX__arcsin"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arccos"
// cWrapperName: "CasADi__MX__arccos"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arctan"
// cWrapperName: "CasADi__MX__arctan"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->arctan() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::floor"
// cWrapperName: "CasADi__MX__floor"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::ceil"
// cWrapperName: "CasADi__MX__ceil"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->ceil() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::fabs"
// cWrapperName: "CasADi__MX__fabs"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->fabs() );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sign"
// cWrapperName: "CasADi__MX__sign"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->sign() );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::erfinv"
// cWrapperName: "CasADi__MX__erfinv"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->erfinv() );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::erf"
// cWrapperName: "CasADi__MX__erf"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->erf() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::sinh"
// cWrapperName: "CasADi__MX__sinh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::cosh"
// cWrapperName: "CasADi__MX__cosh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::tanh"
// cWrapperName: "CasADi__MX__tanh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arcsinh"
// cWrapperName: "CasADi__MX__arcsinh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arccosh"
// cWrapperName: "CasADi__MX__arccosh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::arctanh"
// cWrapperName: "CasADi__MX__arctanh"
// protoArgs: "(CasADi::MX* obj)"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( 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: Val (NonVec (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 new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return new CasADi::MX( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( obj->attachAssert(x0_) );
}


// ================== Normal method: "setSparse" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSparse"
// cWrapperName: "CasADi__MX__setSparse"
// protoArgs: "(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1)"
// call: "obj->setSparse(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1);
CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,bool*>::marshal(x1);

    return new CasADi::MX( obj->setSparse(x0_, x1_) );
}


// ================== Normal method: "setSparse'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setSparse'"
// cWrapperName: "CasADi__MX__setSparse_TIC"
// protoArgs: "(CasADi::MX* obj, CasADi::CRSSparsity* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::CRSSparsity* x0)"
// call: "obj->setSparse(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::CRSSparsity* x0);
CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::MX( obj->setSparse(x0_) );
}


// ================== Normal method: "makeDense" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::makeDense"
// cWrapperName: "CasADi__MX__makeDense"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__makeDense(CasADi::MX* obj, CasADi::MX* x0)"
// call: "obj->makeDense(x0_)"
extern "C"
    CasADi::MX* CasADi__MX__makeDense(CasADi::MX* obj, CasADi::MX* x0);
CasADi::MX* CasADi__MX__makeDense(CasADi::MX* obj, CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( obj->makeDense(x0_) );
}


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

    return new CasADi::MX( obj->makeDense() );
}


// ================== Normal method: "lift" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::lift"
// cWrapperName: "CasADi__MX__lift"
// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return obj->lift(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setMaxNumCallsInPrint"
// cWrapperName: "CasADi__MX__setMaxNumCallsInPrint"
// protoArgs: "(long x0)"
// args: "(x0_)"
// rettype: Val (NonVec 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);

    return CasADi::MX::setMaxNumCallsInPrint(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setMaxNumCallsInPrint'"
// cWrapperName: "CasADi__MX__setMaxNumCallsInPrint_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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(){

    return CasADi::MX::setMaxNumCallsInPrint();
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getMaxNumCallsInPrint"
// cWrapperName: "CasADi__MX__getMaxNumCallsInPrint"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CLong)
// cWrapperRetType: "long"
// proto: "long CasADi__MX__getMaxNumCallsInPrint()"
// call: "CasADi::MX::getMaxNumCallsInPrint()"
extern "C"
    long CasADi__MX__getMaxNumCallsInPrint();
long CasADi__MX__getMaxNumCallsInPrint(){

    return CasADi::MX::getMaxNumCallsInPrint();
}


// ================== Static method: "setEqualityCheckingDepth" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setEqualityCheckingDepth"
// cWrapperName: "CasADi__MX__setEqualityCheckingDepth"
// protoArgs: "(int x0)"
// args: "(x0_)"
// rettype: Val (NonVec 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);

    return CasADi::MX::setEqualityCheckingDepth(x0_);
}


// ================== Static method: "setEqualityCheckingDepth'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::setEqualityCheckingDepth'"
// cWrapperName: "CasADi__MX__setEqualityCheckingDepth_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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(){

    return CasADi::MX::setEqualityCheckingDepth();
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX::getEqualityCheckingDepth"
// cWrapperName: "CasADi__MX__getEqualityCheckingDepth"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__MX__getEqualityCheckingDepth()"
// call: "CasADi::MX::getEqualityCheckingDepth()"
extern "C"
    int CasADi__MX__getEqualityCheckingDepth();
int CasADi__MX__getEqualityCheckingDepth(){

    return CasADi::MX::getEqualityCheckingDepth();
}


// ================== Constructor method: "MX" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::MX( CasADi::MX() );
}


// ================== Constructor method: "MX'" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC"
// protoArgs: "(std::string* x0, int x1, int x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC(std::string* x0, int x1, int x2)"
// call: "CasADi::MX(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC(std::string* x0, int x1, int x2);
CasADi::MX* CasADi__MX__MX_TIC(std::string* x0, int x1, int x2){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::MX( CasADi::MX(x0_, x1_, x2_) );
}


// ================== Constructor method: "MX''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC"
// protoArgs: "(std::string* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC(std::string* x0, int x1)"
// call: "CasADi::MX(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC(std::string* x0, int x1);
CasADi::MX* CasADi__MX__MX_TIC_TIC(std::string* x0, int x1){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::MX( CasADi::MX(x0_, x1_) );
}


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

    return new CasADi::MX( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::MX(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::MX( CasADi::MX(x0_, x1_) );
}


// ================== Constructor method: "MX'''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0, CasADi::MX* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::MX* x1)"
// call: "CasADi::MX(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::MX* x1);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::MX* x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::MX(x0_, x1_) );
}


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

    return new CasADi::MX( CasADi::MX(x0_) );
}


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

    return new CasADi::MX( 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::MX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_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_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX'''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<double > * x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_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_TIC_TIC(std::vector<double > * x0);
CasADi::MX* CasADi__MX__MX_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 new CasADi::MX( CasADi::MX(x0_) );
}


// ================== Constructor method: "MX''''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_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_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::MX( CasADi::MX(x0_) );
}


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

    return new CasADi::MX( CasADi::MX(x0_, x1_) );
}


// ================== Constructor method: "MX''''''''''''" ===============
// class: "CasADi::MX"
// cppName: "CasADi::MX"
// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(int x0, int x1, CasADi::MX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass MX))
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1, CasADi::MX* x2)"
// call: "CasADi::MX(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1, CasADi::MX* x2);
CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1, CasADi::MX* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);

    return new CasADi::MX( CasADi::MX(x0_, x1_, x2_) );
}


// ================== delete CasadiClass CasadiOptions===============
// classType: CasadiClass CasadiOptions
extern "C"
    void delete_CasADi__CasadiOptions(CasADi::CasadiOptions* obj);
void delete_CasADi__CasadiOptions(CasADi::CasadiOptions* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__CasadiOptions_(std::vector<CasADi::CasadiOptions* >* obj);
void delete_std__vector_CasADi__CasadiOptions_(std::vector<CasADi::CasadiOptions* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__CasadiOptions__(std::vector<std::vector<CasADi::CasadiOptions* > >* obj);
void delete_std__vector_std__vector_CasADi__CasadiOptions__(std::vector<std::vector<CasADi::CasadiOptions* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___(std::vector<std::vector<std::vector<CasADi::CasadiOptions* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___(std::vector<std::vector<std::vector<CasADi::CasadiOptions* > > >* obj){
    delete obj;
}

// ================== Static method: "setCatchErrorsPython" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setCatchErrorsPython"
// cWrapperName: "CasADi__CasadiOptions__setCatchErrorsPython"
// protoArgs: "(bool* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setCatchErrorsPython(bool* x0)"
// call: "CasADi::CasadiOptions::setCatchErrorsPython(x0_)"
extern "C"
    void CasADi__CasadiOptions__setCatchErrorsPython(bool* x0);
void CasADi__CasadiOptions__setCatchErrorsPython(bool* x0){
    bool x0_ = Marshaling<bool,bool*>::marshal(x0);

    return CasADi::CasadiOptions::setCatchErrorsPython(x0_);
}


// ================== Static method: "getCatchErrorsPython" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::getCatchErrorsPython"
// cWrapperName: "CasADi__CasadiOptions__getCatchErrorsPython"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CasadiOptions__getCatchErrorsPython()"
// call: "CasADi::CasadiOptions::getCatchErrorsPython()"
extern "C"
    bool* CasADi__CasadiOptions__getCatchErrorsPython();
bool* CasADi__CasadiOptions__getCatchErrorsPython(){

    return new bool( CasADi::CasadiOptions::getCatchErrorsPython() );
}


// ================== Static method: "setSimplificationOnTheFly" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::setSimplificationOnTheFly"
// cWrapperName: "CasADi__CasadiOptions__setSimplificationOnTheFly"
// protoArgs: "(bool* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__setSimplificationOnTheFly(bool* x0)"
// call: "CasADi::CasadiOptions::setSimplificationOnTheFly(x0_)"
extern "C"
    void CasADi__CasadiOptions__setSimplificationOnTheFly(bool* x0);
void CasADi__CasadiOptions__setSimplificationOnTheFly(bool* x0){
    bool x0_ = Marshaling<bool,bool*>::marshal(x0);

    return CasADi::CasadiOptions::setSimplificationOnTheFly(x0_);
}


// ================== Static method: "getSimplificationOnTheFly" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::getSimplificationOnTheFly"
// cWrapperName: "CasADi__CasadiOptions__getSimplificationOnTheFly"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CasadiOptions__getSimplificationOnTheFly()"
// call: "CasADi::CasadiOptions::getSimplificationOnTheFly()"
extern "C"
    bool* CasADi__CasadiOptions__getSimplificationOnTheFly();
bool* CasADi__CasadiOptions__getSimplificationOnTheFly(){

    return new bool( CasADi::CasadiOptions::getSimplificationOnTheFly() );
}


// ================== Static method: "startProfiling" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::startProfiling"
// cWrapperName: "CasADi__CasadiOptions__startProfiling"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec 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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return CasADi::CasadiOptions::startProfiling(x0_);
}


// ================== Static method: "stopProfiling" ===============
// class: "CasADi::CasadiOptions"
// cppName: "CasADi::CasadiOptions::stopProfiling"
// cWrapperName: "CasADi__CasadiOptions__stopProfiling"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__CasadiOptions__stopProfiling()"
// call: "CasADi::CasadiOptions::stopProfiling()"
extern "C"
    void CasADi__CasadiOptions__stopProfiling();
void CasADi__CasadiOptions__stopProfiling(){

    return CasADi::CasadiOptions::stopProfiling();
}


// ================== delete CasadiClass Callback===============
// classType: CasadiClass Callback
extern "C"
    void delete_CasADi__Callback(CasADi::Callback* obj);
void delete_CasADi__Callback(CasADi::Callback* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__Callback_(std::vector<CasADi::Callback* >* obj);
void delete_std__vector_CasADi__Callback_(std::vector<CasADi::Callback* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__Callback__(std::vector<std::vector<CasADi::Callback* > >* obj);
void delete_std__vector_std__vector_CasADi__Callback__(std::vector<std::vector<CasADi::Callback* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__Callback___(std::vector<std::vector<std::vector<CasADi::Callback* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__Callback___(std::vector<std::vector<std::vector<CasADi::Callback* > > >* obj){
    delete obj;
}

// ================== Constructor method: "Callback" ===============
// class: "CasADi::Callback"
// cppName: "CasADi::Callback"
// cWrapperName: "CasADi__Callback__Callback"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::Callback( CasADi::Callback() );
}


// ================== delete CasadiClass CustomEvaluate===============
// classType: CasadiClass CustomEvaluate
extern "C"
    void delete_CasADi__CustomEvaluate(CasADi::CustomEvaluate* obj);
void delete_CasADi__CustomEvaluate(CasADi::CustomEvaluate* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__CustomEvaluate_(std::vector<CasADi::CustomEvaluate* >* obj);
void delete_std__vector_CasADi__CustomEvaluate_(std::vector<CasADi::CustomEvaluate* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__CustomEvaluate__(std::vector<std::vector<CasADi::CustomEvaluate* > >* obj);
void delete_std__vector_std__vector_CasADi__CustomEvaluate__(std::vector<std::vector<CasADi::CustomEvaluate* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___(std::vector<std::vector<std::vector<CasADi::CustomEvaluate* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___(std::vector<std::vector<std::vector<CasADi::CustomEvaluate* > > >* obj){
    delete obj;
}

// ================== Constructor method: "CustomEvaluate" ===============
// class: "CasADi::CustomEvaluate"
// cppName: "CasADi::CustomEvaluate"
// cWrapperName: "CasADi__CustomEvaluate__CustomEvaluate"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::CustomEvaluate( CasADi::CustomEvaluate() );
}


// ================== delete CasadiClass ExternalFunction===============
// classType: CasadiClass ExternalFunction
extern "C"
    void delete_CasADi__ExternalFunction(CasADi::ExternalFunction* obj);
void delete_CasADi__ExternalFunction(CasADi::ExternalFunction* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__ExternalFunction_(std::vector<CasADi::ExternalFunction* >* obj);
void delete_std__vector_CasADi__ExternalFunction_(std::vector<CasADi::ExternalFunction* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__ExternalFunction__(std::vector<std::vector<CasADi::ExternalFunction* > >* obj);
void delete_std__vector_std__vector_CasADi__ExternalFunction__(std::vector<std::vector<CasADi::ExternalFunction* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___(std::vector<std::vector<std::vector<CasADi::ExternalFunction* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___(std::vector<std::vector<std::vector<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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    bool* CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj);
bool* CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj){

    return new bool( obj->checkNode() );
}


// ================== Constructor method: "ExternalFunction" ===============
// class: "CasADi::ExternalFunction"
// cppName: "CasADi::ExternalFunction"
// cWrapperName: "CasADi__ExternalFunction__ExternalFunction"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::ExternalFunction( CasADi::ExternalFunction() );
}


// ================== Constructor method: "ExternalFunction'" ===============
// class: "CasADi::ExternalFunction"
// cppName: "CasADi::ExternalFunction"
// cWrapperName: "CasADi__ExternalFunction__ExternalFunction_TIC"
// protoArgs: "(std::string* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (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 x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::ExternalFunction( CasADi::ExternalFunction(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;
}
extern "C"
    void delete_std__vector_CasADi__CSparse_(std::vector<CasADi::CSparse* >* obj);
void delete_std__vector_CasADi__CSparse_(std::vector<CasADi::CSparse* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__CSparse__(std::vector<std::vector<CasADi::CSparse* > >* obj);
void delete_std__vector_std__vector_CasADi__CSparse__(std::vector<std::vector<CasADi::CSparse* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__CSparse___(std::vector<std::vector<std::vector<CasADi::CSparse* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__CSparse___(std::vector<std::vector<std::vector<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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CSparse__checkNode(CasADi::CSparse* obj)"
// call: "obj->checkNode()"
extern "C"
    bool* CasADi__CSparse__checkNode(CasADi::CSparse* obj);
bool* CasADi__CSparse__checkNode(CasADi::CSparse* obj){

    return new bool( obj->checkNode() );
}


// ================== Constructor method: "CSparse" ===============
// class: "CasADi::CSparse"
// cppName: "CasADi::CSparse"
// cWrapperName: "CasADi__CSparse__CSparse"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::CSparse( CasADi::CSparse() );
}


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

    return new CasADi::CSparse( CasADi::CSparse(x0_, x1_) );
}


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

    return new CasADi::CSparse( CasADi::CSparse(x0_) );
}


// ================== delete CasadiClass SX===============
// classType: CasadiClass SX
extern "C"
    void delete_CasADi__SX(CasADi::SX* obj);
void delete_CasADi__SX(CasADi::SX* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__SX_(std::vector<CasADi::SX* >* obj);
void delete_std__vector_CasADi__SX_(std::vector<CasADi::SX* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__SX__(std::vector<std::vector<CasADi::SX* > >* obj);
void delete_std__vector_std__vector_CasADi__SX__(std::vector<std::vector<CasADi::SX* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__SX___(std::vector<std::vector<std::vector<CasADi::SX* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__SX___(std::vector<std::vector<std::vector<CasADi::SX* > > >* obj){
    delete obj;
}

// ================== Static method: "binary" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::binary"
// cWrapperName: "CasADi__SX__binary"
// protoArgs: "(int x0, CasADi::SX* x1, CasADi::SX* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__binary(int x0, CasADi::SX* x1, CasADi::SX* x2)"
// call: "CasADi::SX::binary(x0_, x1_, x2_)"
extern "C"
    CasADi::SX* CasADi__SX__binary(int x0, CasADi::SX* x1, CasADi::SX* x2);
CasADi::SX* CasADi__SX__binary(int x0, CasADi::SX* x1, CasADi::SX* x2){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);
    CasADi::SX x2_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x2);

    return new CasADi::SX( CasADi::SX::binary(x0_, x1_, x2_) );
}


// ================== Static method: "unary" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::unary"
// cWrapperName: "CasADi__SX__unary"
// protoArgs: "(int x0, CasADi::SX* x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__unary(int x0, CasADi::SX* x1)"
// call: "CasADi::SX::unary(x0_, x1_)"
extern "C"
    CasADi::SX* CasADi__SX__unary(int x0, CasADi::SX* x1);
CasADi::SX* CasADi__SX__unary(int x0, CasADi::SX* x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);

    return new CasADi::SX( CasADi::SX::unary(x0_, x1_) );
}


// ================== Normal method: "__nonzero__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__nonzero__"
// cWrapperName: "CasADi__SX____nonzero__"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX____nonzero__(CasADi::SX* obj)"
// call: "obj->__nonzero__()"
extern "C"
    bool* CasADi__SX____nonzero__(CasADi::SX* obj);
bool* CasADi__SX____nonzero__(CasADi::SX* obj){

    return new bool( obj->__nonzero__() );
}


// ================== Normal method: "isLeaf" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isLeaf"
// cWrapperName: "CasADi__SX__isLeaf"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isLeaf(CasADi::SX* obj)"
// call: "obj->isLeaf()"
extern "C"
    bool* CasADi__SX__isLeaf(CasADi::SX* obj);
bool* CasADi__SX__isLeaf(CasADi::SX* obj){

    return new bool( obj->isLeaf() );
}


// ================== Normal method: "isConstant" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isConstant"
// cWrapperName: "CasADi__SX__isConstant"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isConstant(CasADi::SX* obj)"
// call: "obj->isConstant()"
extern "C"
    bool* CasADi__SX__isConstant(CasADi::SX* obj);
bool* CasADi__SX__isConstant(CasADi::SX* obj){

    return new bool( obj->isConstant() );
}


// ================== Normal method: "isInteger" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isInteger"
// cWrapperName: "CasADi__SX__isInteger"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isInteger(CasADi::SX* obj)"
// call: "obj->isInteger()"
extern "C"
    bool* CasADi__SX__isInteger(CasADi::SX* obj);
bool* CasADi__SX__isInteger(CasADi::SX* obj){

    return new bool( obj->isInteger() );
}


// ================== Normal method: "isSymbolic" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isSymbolic"
// cWrapperName: "CasADi__SX__isSymbolic"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isSymbolic(CasADi::SX* obj)"
// call: "obj->isSymbolic()"
extern "C"
    bool* CasADi__SX__isSymbolic(CasADi::SX* obj);
bool* CasADi__SX__isSymbolic(CasADi::SX* obj){

    return new bool( obj->isSymbolic() );
}


// ================== Normal method: "hasDep" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::hasDep"
// cWrapperName: "CasADi__SX__hasDep"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__hasDep(CasADi::SX* obj)"
// call: "obj->hasDep()"
extern "C"
    bool* CasADi__SX__hasDep(CasADi::SX* obj);
bool* CasADi__SX__hasDep(CasADi::SX* obj){

    return new bool( obj->hasDep() );
}


// ================== Normal method: "isCommutative" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isCommutative"
// cWrapperName: "CasADi__SX__isCommutative"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isCommutative(CasADi::SX* obj)"
// call: "obj->isCommutative()"
extern "C"
    bool* CasADi__SX__isCommutative(CasADi::SX* obj);
bool* CasADi__SX__isCommutative(CasADi::SX* obj){

    return new bool( obj->isCommutative() );
}


// ================== Normal method: "isZero" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isZero"
// cWrapperName: "CasADi__SX__isZero"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isZero(CasADi::SX* obj)"
// call: "obj->isZero()"
extern "C"
    bool* CasADi__SX__isZero(CasADi::SX* obj);
bool* CasADi__SX__isZero(CasADi::SX* obj){

    return new bool( obj->isZero() );
}


// ================== Normal method: "isOne" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isOne"
// cWrapperName: "CasADi__SX__isOne"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isOne(CasADi::SX* obj)"
// call: "obj->isOne()"
extern "C"
    bool* CasADi__SX__isOne(CasADi::SX* obj);
bool* CasADi__SX__isOne(CasADi::SX* obj){

    return new bool( obj->isOne() );
}


// ================== Normal method: "isMinusOne" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isMinusOne"
// cWrapperName: "CasADi__SX__isMinusOne"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isMinusOne(CasADi::SX* obj)"
// call: "obj->isMinusOne()"
extern "C"
    bool* CasADi__SX__isMinusOne(CasADi::SX* obj);
bool* CasADi__SX__isMinusOne(CasADi::SX* obj){

    return new bool( obj->isMinusOne() );
}


// ================== Normal method: "isNan" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isNan"
// cWrapperName: "CasADi__SX__isNan"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isNan(CasADi::SX* obj)"
// call: "obj->isNan()"
extern "C"
    bool* CasADi__SX__isNan(CasADi::SX* obj);
bool* CasADi__SX__isNan(CasADi::SX* obj){

    return new bool( obj->isNan() );
}


// ================== Normal method: "isInf" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isInf"
// cWrapperName: "CasADi__SX__isInf"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isInf(CasADi::SX* obj)"
// call: "obj->isInf()"
extern "C"
    bool* CasADi__SX__isInf(CasADi::SX* obj);
bool* CasADi__SX__isInf(CasADi::SX* obj){

    return new bool( obj->isInf() );
}


// ================== Normal method: "isMinusInf" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isMinusInf"
// cWrapperName: "CasADi__SX__isMinusInf"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isMinusInf(CasADi::SX* obj)"
// call: "obj->isMinusInf()"
extern "C"
    bool* CasADi__SX__isMinusInf(CasADi::SX* obj);
bool* CasADi__SX__isMinusInf(CasADi::SX* obj){

    return new bool( obj->isMinusInf() );
}


// ================== Normal method: "getOp" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getOp"
// cWrapperName: "CasADi__SX__getOp"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__SX__getOp(CasADi::SX* obj)"
// call: "obj->getOp()"
extern "C"
    int CasADi__SX__getOp(CasADi::SX* obj);
int CasADi__SX__getOp(CasADi::SX* obj){

    return obj->getOp();
}


// ================== Normal method: "isOp" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isOp"
// cWrapperName: "CasADi__SX__isOp"
// protoArgs: "(CasADi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isOp(CasADi::SX* obj, int x0)"
// call: "obj->isOp(x0_)"
extern "C"
    bool* CasADi__SX__isOp(CasADi::SX* obj, int x0);
bool* CasADi__SX__isOp(CasADi::SX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new bool( obj->isOp(x0_) );
}


// ================== Normal method: "isEqual" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isEqual"
// cWrapperName: "CasADi__SX__isEqual"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isEqual(CasADi::SX* obj, CasADi::SX* x0, int x1)"
// call: "obj->isEqual(x0_, x1_)"
extern "C"
    bool* CasADi__SX__isEqual(CasADi::SX* obj, CasADi::SX* x0, int x1);
bool* CasADi__SX__isEqual(CasADi::SX* obj, CasADi::SX* x0, int x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new bool( obj->isEqual(x0_, x1_) );
}


// ================== Normal method: "isEqual'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isEqual'"
// cWrapperName: "CasADi__SX__isEqual_TIC"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isEqual_TIC(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->isEqual(x0_)"
extern "C"
    bool* CasADi__SX__isEqual_TIC(CasADi::SX* obj, CasADi::SX* x0);
bool* CasADi__SX__isEqual_TIC(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new bool( obj->isEqual(x0_) );
}


// ================== Normal method: "isNonNegative" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isNonNegative"
// cWrapperName: "CasADi__SX__isNonNegative"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isNonNegative(CasADi::SX* obj)"
// call: "obj->isNonNegative()"
extern "C"
    bool* CasADi__SX__isNonNegative(CasADi::SX* obj);
bool* CasADi__SX__isNonNegative(CasADi::SX* obj){

    return new bool( obj->isNonNegative() );
}


// ================== Normal method: "getValue" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getValue"
// cWrapperName: "CasADi__SX__getValue"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CDouble)
// cWrapperRetType: "double"
// proto: "double CasADi__SX__getValue(CasADi::SX* obj)"
// call: "obj->getValue()"
extern "C"
    double CasADi__SX__getValue(CasADi::SX* obj);
double CasADi__SX__getValue(CasADi::SX* obj){

    return obj->getValue();
}


// ================== Normal method: "getIntValue" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getIntValue"
// cWrapperName: "CasADi__SX__getIntValue"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__SX__getIntValue(CasADi::SX* obj)"
// call: "obj->getIntValue()"
extern "C"
    int CasADi__SX__getIntValue(CasADi::SX* obj);
int CasADi__SX__getIntValue(CasADi::SX* obj){

    return obj->getIntValue();
}


// ================== Normal method: "getDep" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getDep"
// cWrapperName: "CasADi__SX__getDep"
// protoArgs: "(CasADi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__getDep(CasADi::SX* obj, int x0)"
// call: "obj->getDep(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__getDep(CasADi::SX* obj, int x0);
CasADi::SX* CasADi__SX__getDep(CasADi::SX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::SX( obj->getDep(x0_) );
}


// ================== Normal method: "getDep'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getDep'"
// cWrapperName: "CasADi__SX__getDep_TIC"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__getDep_TIC(CasADi::SX* obj)"
// call: "obj->getDep()"
extern "C"
    CasADi::SX* CasADi__SX__getDep_TIC(CasADi::SX* obj);
CasADi::SX* CasADi__SX__getDep_TIC(CasADi::SX* obj){

    return new CasADi::SX( obj->getDep() );
}


// ================== Normal method: "isDoubled" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isDoubled"
// cWrapperName: "CasADi__SX__isDoubled"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isDoubled(CasADi::SX* obj)"
// call: "obj->isDoubled()"
extern "C"
    bool* CasADi__SX__isDoubled(CasADi::SX* obj);
bool* CasADi__SX__isDoubled(CasADi::SX* obj){

    return new bool( obj->isDoubled() );
}


// ================== Normal method: "getNdeps" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getNdeps"
// cWrapperName: "CasADi__SX__getNdeps"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__SX__getNdeps(CasADi::SX* obj)"
// call: "obj->getNdeps()"
extern "C"
    int CasADi__SX__getNdeps(CasADi::SX* obj);
int CasADi__SX__getNdeps(CasADi::SX* obj){

    return obj->getNdeps();
}


// ================== Normal method: "__hash__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__hash__"
// cWrapperName: "CasADi__SX____hash__"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CLong)
// cWrapperRetType: "long"
// proto: "long CasADi__SX____hash__(CasADi::SX* obj)"
// call: "obj->__hash__()"
extern "C"
    long CasADi__SX____hash__(CasADi::SX* obj);
long CasADi__SX____hash__(CasADi::SX* obj){

    return obj->__hash__();
}


// ================== Normal method: "operator -" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::operator -"
// cWrapperName: "CasADi__SX__operator_minus"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__operator_minus(CasADi::SX* obj)"
// call: "obj->operator -()"
extern "C"
    CasADi::SX* CasADi__SX__operator_minus(CasADi::SX* obj);
CasADi::SX* CasADi__SX__operator_minus(CasADi::SX* obj){

    return new CasADi::SX( obj->operator -() );
}


// ================== Normal method: "__add__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__add__"
// cWrapperName: "CasADi__SX____add__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____add__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__add__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____add__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____add__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__add__(x0_) );
}


// ================== Normal method: "__sub__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__sub__"
// cWrapperName: "CasADi__SX____sub__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____sub__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__sub__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____sub__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____sub__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__sub__(x0_) );
}


// ================== Normal method: "__mul__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__mul__"
// cWrapperName: "CasADi__SX____mul__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____mul__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__mul__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____mul__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____mul__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__mul__(x0_) );
}


// ================== Normal method: "__div__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__div__"
// cWrapperName: "CasADi__SX____div__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____div__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__div__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____div__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____div__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__div__(x0_) );
}


// ================== Normal method: "__lt__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__lt__"
// cWrapperName: "CasADi__SX____lt__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____lt__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__lt__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____lt__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____lt__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__lt__(x0_) );
}


// ================== Normal method: "__le__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__le__"
// cWrapperName: "CasADi__SX____le__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____le__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__le__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____le__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____le__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__le__(x0_) );
}


// ================== Normal method: "__eq__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__eq__"
// cWrapperName: "CasADi__SX____eq__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____eq__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__eq__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____eq__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____eq__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__eq__(x0_) );
}


// ================== Normal method: "__ne__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__ne__"
// cWrapperName: "CasADi__SX____ne__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____ne__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__ne__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____ne__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____ne__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__ne__(x0_) );
}


// ================== Normal method: "__truediv__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__truediv__"
// cWrapperName: "CasADi__SX____truediv__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____truediv__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__truediv__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____truediv__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____truediv__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__truediv__(x0_) );
}


// ================== Normal method: "__pow__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__pow__"
// cWrapperName: "CasADi__SX____pow__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____pow__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__pow__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____pow__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____pow__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__pow__(x0_) );
}


// ================== Normal method: "__constpow__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__constpow__"
// cWrapperName: "CasADi__SX____constpow__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____constpow__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__constpow__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____constpow__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____constpow__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__constpow__(x0_) );
}


// ================== Normal method: "__mrdivide__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__mrdivide__"
// cWrapperName: "CasADi__SX____mrdivide__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____mrdivide__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__mrdivide__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____mrdivide__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____mrdivide__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__mrdivide__(x0_) );
}


// ================== Normal method: "__mpower__" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::__mpower__"
// cWrapperName: "CasADi__SX____mpower__"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX____mpower__(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->__mpower__(x0_)"
extern "C"
    CasADi::SX* CasADi__SX____mpower__(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX____mpower__(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->__mpower__(x0_) );
}


// ================== Normal method: "trans" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::trans"
// cWrapperName: "CasADi__SX__trans"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__trans(CasADi::SX* obj)"
// call: "obj->trans()"
extern "C"
    CasADi::SX* CasADi__SX__trans(CasADi::SX* obj);
CasADi::SX* CasADi__SX__trans(CasADi::SX* obj){

    return new CasADi::SX( obj->trans() );
}


// ================== Normal method: "mul" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::mul"
// cWrapperName: "CasADi__SX__mul"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__mul(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->mul(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__mul(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__mul(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->mul(x0_) );
}


// ================== Normal method: "exp" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::exp"
// cWrapperName: "CasADi__SX__exp"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__exp(CasADi::SX* obj)"
// call: "obj->exp()"
extern "C"
    CasADi::SX* CasADi__SX__exp(CasADi::SX* obj);
CasADi::SX* CasADi__SX__exp(CasADi::SX* obj){

    return new CasADi::SX( obj->exp() );
}


// ================== Normal method: "log" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::log"
// cWrapperName: "CasADi__SX__log"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__log(CasADi::SX* obj)"
// call: "obj->log()"
extern "C"
    CasADi::SX* CasADi__SX__log(CasADi::SX* obj);
CasADi::SX* CasADi__SX__log(CasADi::SX* obj){

    return new CasADi::SX( obj->log() );
}


// ================== Normal method: "sqrt" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::sqrt"
// cWrapperName: "CasADi__SX__sqrt"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__sqrt(CasADi::SX* obj)"
// call: "obj->sqrt()"
extern "C"
    CasADi::SX* CasADi__SX__sqrt(CasADi::SX* obj);
CasADi::SX* CasADi__SX__sqrt(CasADi::SX* obj){

    return new CasADi::SX( obj->sqrt() );
}


// ================== Normal method: "sq" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::sq"
// cWrapperName: "CasADi__SX__sq"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__sq(CasADi::SX* obj)"
// call: "obj->sq()"
extern "C"
    CasADi::SX* CasADi__SX__sq(CasADi::SX* obj);
CasADi::SX* CasADi__SX__sq(CasADi::SX* obj){

    return new CasADi::SX( obj->sq() );
}


// ================== Normal method: "sin" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::sin"
// cWrapperName: "CasADi__SX__sin"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__sin(CasADi::SX* obj)"
// call: "obj->sin()"
extern "C"
    CasADi::SX* CasADi__SX__sin(CasADi::SX* obj);
CasADi::SX* CasADi__SX__sin(CasADi::SX* obj){

    return new CasADi::SX( obj->sin() );
}


// ================== Normal method: "cos" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::cos"
// cWrapperName: "CasADi__SX__cos"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__cos(CasADi::SX* obj)"
// call: "obj->cos()"
extern "C"
    CasADi::SX* CasADi__SX__cos(CasADi::SX* obj);
CasADi::SX* CasADi__SX__cos(CasADi::SX* obj){

    return new CasADi::SX( obj->cos() );
}


// ================== Normal method: "tan" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::tan"
// cWrapperName: "CasADi__SX__tan"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__tan(CasADi::SX* obj)"
// call: "obj->tan()"
extern "C"
    CasADi::SX* CasADi__SX__tan(CasADi::SX* obj);
CasADi::SX* CasADi__SX__tan(CasADi::SX* obj){

    return new CasADi::SX( obj->tan() );
}


// ================== Normal method: "arcsin" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arcsin"
// cWrapperName: "CasADi__SX__arcsin"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arcsin(CasADi::SX* obj)"
// call: "obj->arcsin()"
extern "C"
    CasADi::SX* CasADi__SX__arcsin(CasADi::SX* obj);
CasADi::SX* CasADi__SX__arcsin(CasADi::SX* obj){

    return new CasADi::SX( obj->arcsin() );
}


// ================== Normal method: "arccos" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arccos"
// cWrapperName: "CasADi__SX__arccos"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arccos(CasADi::SX* obj)"
// call: "obj->arccos()"
extern "C"
    CasADi::SX* CasADi__SX__arccos(CasADi::SX* obj);
CasADi::SX* CasADi__SX__arccos(CasADi::SX* obj){

    return new CasADi::SX( obj->arccos() );
}


// ================== Normal method: "arctan" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arctan"
// cWrapperName: "CasADi__SX__arctan"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arctan(CasADi::SX* obj)"
// call: "obj->arctan()"
extern "C"
    CasADi::SX* CasADi__SX__arctan(CasADi::SX* obj);
CasADi::SX* CasADi__SX__arctan(CasADi::SX* obj){

    return new CasADi::SX( obj->arctan() );
}


// ================== Normal method: "floor" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::floor"
// cWrapperName: "CasADi__SX__floor"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__floor(CasADi::SX* obj)"
// call: "obj->floor()"
extern "C"
    CasADi::SX* CasADi__SX__floor(CasADi::SX* obj);
CasADi::SX* CasADi__SX__floor(CasADi::SX* obj){

    return new CasADi::SX( obj->floor() );
}


// ================== Normal method: "ceil" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::ceil"
// cWrapperName: "CasADi__SX__ceil"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__ceil(CasADi::SX* obj)"
// call: "obj->ceil()"
extern "C"
    CasADi::SX* CasADi__SX__ceil(CasADi::SX* obj);
CasADi::SX* CasADi__SX__ceil(CasADi::SX* obj){

    return new CasADi::SX( obj->ceil() );
}


// ================== Normal method: "erf" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::erf"
// cWrapperName: "CasADi__SX__erf"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__erf(CasADi::SX* obj)"
// call: "obj->erf()"
extern "C"
    CasADi::SX* CasADi__SX__erf(CasADi::SX* obj);
CasADi::SX* CasADi__SX__erf(CasADi::SX* obj){

    return new CasADi::SX( obj->erf() );
}


// ================== Normal method: "erfinv" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::erfinv"
// cWrapperName: "CasADi__SX__erfinv"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__erfinv(CasADi::SX* obj)"
// call: "obj->erfinv()"
extern "C"
    CasADi::SX* CasADi__SX__erfinv(CasADi::SX* obj);
CasADi::SX* CasADi__SX__erfinv(CasADi::SX* obj){

    return new CasADi::SX( obj->erfinv() );
}


// ================== Normal method: "fabs" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::fabs"
// cWrapperName: "CasADi__SX__fabs"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__fabs(CasADi::SX* obj)"
// call: "obj->fabs()"
extern "C"
    CasADi::SX* CasADi__SX__fabs(CasADi::SX* obj);
CasADi::SX* CasADi__SX__fabs(CasADi::SX* obj){

    return new CasADi::SX( obj->fabs() );
}


// ================== Normal method: "fmin" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::fmin"
// cWrapperName: "CasADi__SX__fmin"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__fmin(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__fmin(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__fmin(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->fmin(x0_) );
}


// ================== Normal method: "fmax" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::fmax"
// cWrapperName: "CasADi__SX__fmax"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__fmax(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__fmax(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__fmax(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->fmax(x0_) );
}


// ================== Normal method: "inv" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::inv"
// cWrapperName: "CasADi__SX__inv"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__inv(CasADi::SX* obj)"
// call: "obj->inv()"
extern "C"
    CasADi::SX* CasADi__SX__inv(CasADi::SX* obj);
CasADi::SX* CasADi__SX__inv(CasADi::SX* obj){

    return new CasADi::SX( obj->inv() );
}


// ================== Normal method: "sinh" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::sinh"
// cWrapperName: "CasADi__SX__sinh"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__sinh(CasADi::SX* obj)"
// call: "obj->sinh()"
extern "C"
    CasADi::SX* CasADi__SX__sinh(CasADi::SX* obj);
CasADi::SX* CasADi__SX__sinh(CasADi::SX* obj){

    return new CasADi::SX( obj->sinh() );
}


// ================== Normal method: "cosh" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::cosh"
// cWrapperName: "CasADi__SX__cosh"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__cosh(CasADi::SX* obj)"
// call: "obj->cosh()"
extern "C"
    CasADi::SX* CasADi__SX__cosh(CasADi::SX* obj);
CasADi::SX* CasADi__SX__cosh(CasADi::SX* obj){

    return new CasADi::SX( obj->cosh() );
}


// ================== Normal method: "tanh" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::tanh"
// cWrapperName: "CasADi__SX__tanh"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__tanh(CasADi::SX* obj)"
// call: "obj->tanh()"
extern "C"
    CasADi::SX* CasADi__SX__tanh(CasADi::SX* obj);
CasADi::SX* CasADi__SX__tanh(CasADi::SX* obj){

    return new CasADi::SX( obj->tanh() );
}


// ================== Normal method: "arcsinh" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arcsinh"
// cWrapperName: "CasADi__SX__arcsinh"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arcsinh(CasADi::SX* obj)"
// call: "obj->arcsinh()"
extern "C"
    CasADi::SX* CasADi__SX__arcsinh(CasADi::SX* obj);
CasADi::SX* CasADi__SX__arcsinh(CasADi::SX* obj){

    return new CasADi::SX( obj->arcsinh() );
}


// ================== Normal method: "arccosh" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arccosh"
// cWrapperName: "CasADi__SX__arccosh"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arccosh(CasADi::SX* obj)"
// call: "obj->arccosh()"
extern "C"
    CasADi::SX* CasADi__SX__arccosh(CasADi::SX* obj);
CasADi::SX* CasADi__SX__arccosh(CasADi::SX* obj){

    return new CasADi::SX( obj->arccosh() );
}


// ================== Normal method: "arctanh" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arctanh"
// cWrapperName: "CasADi__SX__arctanh"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arctanh(CasADi::SX* obj)"
// call: "obj->arctanh()"
extern "C"
    CasADi::SX* CasADi__SX__arctanh(CasADi::SX* obj);
CasADi::SX* CasADi__SX__arctanh(CasADi::SX* obj){

    return new CasADi::SX( obj->arctanh() );
}


// ================== Normal method: "arctan2" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arctan2"
// cWrapperName: "CasADi__SX__arctan2"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__arctan2(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__arctan2(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__arctan2(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->arctan2(x0_) );
}


// ================== Normal method: "log10" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::log10"
// cWrapperName: "CasADi__SX__log10"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__log10(CasADi::SX* obj)"
// call: "obj->log10()"
extern "C"
    CasADi::SX* CasADi__SX__log10(CasADi::SX* obj);
CasADi::SX* CasADi__SX__log10(CasADi::SX* obj){

    return new CasADi::SX( obj->log10() );
}


// ================== Normal method: "printme" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::printme"
// cWrapperName: "CasADi__SX__printme"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__printme(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->printme(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__printme(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__printme(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->printme(x0_) );
}


// ================== Normal method: "sign" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::sign"
// cWrapperName: "CasADi__SX__sign"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__sign(CasADi::SX* obj)"
// call: "obj->sign()"
extern "C"
    CasADi::SX* CasADi__SX__sign(CasADi::SX* obj);
CasADi::SX* CasADi__SX__sign(CasADi::SX* obj){

    return new CasADi::SX( obj->sign() );
}


// ================== Normal method: "constpow" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::constpow"
// cWrapperName: "CasADi__SX__constpow"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__constpow(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->constpow(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__constpow(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__constpow(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->constpow(x0_) );
}


// ================== Normal method: "logic_not" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::logic_not"
// cWrapperName: "CasADi__SX__logic_not"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__logic_not(CasADi::SX* obj)"
// call: "obj->logic_not()"
extern "C"
    CasADi::SX* CasADi__SX__logic_not(CasADi::SX* obj);
CasADi::SX* CasADi__SX__logic_not(CasADi::SX* obj){

    return new CasADi::SX( obj->logic_not() );
}


// ================== Normal method: "logic_and" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::logic_and"
// cWrapperName: "CasADi__SX__logic_and"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__logic_and(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->logic_and(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__logic_and(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__logic_and(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->logic_and(x0_) );
}


// ================== Normal method: "logic_or" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::logic_or"
// cWrapperName: "CasADi__SX__logic_or"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__logic_or(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->logic_or(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__logic_or(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__logic_or(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->logic_or(x0_) );
}


// ================== Normal method: "if_else_zero" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::if_else_zero"
// cWrapperName: "CasADi__SX__if_else_zero"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SX))
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__SX__if_else_zero(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->if_else_zero(x0_)"
extern "C"
    CasADi::SX* CasADi__SX__if_else_zero(CasADi::SX* obj, CasADi::SX* x0);
CasADi::SX* CasADi__SX__if_else_zero(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( obj->if_else_zero(x0_) );
}


// ================== Normal method: "fmin'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::fmin'"
// cWrapperName: "CasADi__SX__fmin_TIC"
// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__fmin_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->fmin(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SX__fmin_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__SX__fmin_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->fmin(x0_) );
}


// ================== Normal method: "fmax'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::fmax'"
// cWrapperName: "CasADi__SX__fmax_TIC"
// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__fmax_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->fmax(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SX__fmax_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__SX__fmax_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->fmax(x0_) );
}


// ================== Normal method: "constpow'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::constpow'"
// cWrapperName: "CasADi__SX__constpow_TIC"
// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__constpow_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->constpow(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SX__constpow_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__SX__constpow_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->constpow(x0_) );
}


// ================== Normal method: "arctan2'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::arctan2'"
// cWrapperName: "CasADi__SX__arctan2_TIC"
// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// args: "(x0_)"
// rettype: Val (NonVec (CasadiClass SXMatrix))
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__arctan2_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"
// call: "obj->arctan2(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__SX__arctan2_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__SX__arctan2_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( obj->arctan2(x0_) );
}


// ================== Normal method: "getTemp" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getTemp"
// cWrapperName: "CasADi__SX__getTemp"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__SX__getTemp(CasADi::SX* obj)"
// call: "obj->getTemp()"
extern "C"
    int CasADi__SX__getTemp(CasADi::SX* obj);
int CasADi__SX__getTemp(CasADi::SX* obj){

    return obj->getTemp();
}


// ================== Normal method: "setTemp" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::setTemp"
// cWrapperName: "CasADi__SX__setTemp"
// protoArgs: "(CasADi::SX* obj, int x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__SX__setTemp(CasADi::SX* obj, int x0)"
// call: "obj->setTemp(x0_)"
extern "C"
    void CasADi__SX__setTemp(CasADi::SX* obj, int x0);
void CasADi__SX__setTemp(CasADi::SX* obj, int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return obj->setTemp(x0_);
}


// ================== Normal method: "marked" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::marked"
// cWrapperName: "CasADi__SX__marked"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__marked(CasADi::SX* obj)"
// call: "obj->marked()"
extern "C"
    bool* CasADi__SX__marked(CasADi::SX* obj);
bool* CasADi__SX__marked(CasADi::SX* obj){

    return new bool( obj->marked() );
}


// ================== Normal method: "mark" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::mark"
// cWrapperName: "CasADi__SX__mark"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__SX__mark(CasADi::SX* obj)"
// call: "obj->mark()"
extern "C"
    void CasADi__SX__mark(CasADi::SX* obj);
void CasADi__SX__mark(CasADi::SX* obj){

    return obj->mark();
}


// ================== Normal method: "assignIfDuplicate" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::assignIfDuplicate"
// cWrapperName: "CasADi__SX__assignIfDuplicate"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0, int x1)"
// args: "(x0_, x1_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__SX__assignIfDuplicate(CasADi::SX* obj, CasADi::SX* x0, int x1)"
// call: "obj->assignIfDuplicate(x0_, x1_)"
extern "C"
    void CasADi__SX__assignIfDuplicate(CasADi::SX* obj, CasADi::SX* x0, int x1);
void CasADi__SX__assignIfDuplicate(CasADi::SX* obj, CasADi::SX* x0, int x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return obj->assignIfDuplicate(x0_, x1_);
}


// ================== Normal method: "assignIfDuplicate'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::assignIfDuplicate'"
// cWrapperName: "CasADi__SX__assignIfDuplicate_TIC"
// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"
// args: "(x0_)"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__SX__assignIfDuplicate_TIC(CasADi::SX* obj, CasADi::SX* x0)"
// call: "obj->assignIfDuplicate(x0_)"
extern "C"
    void CasADi__SX__assignIfDuplicate_TIC(CasADi::SX* obj, CasADi::SX* x0);
void CasADi__SX__assignIfDuplicate_TIC(CasADi::SX* obj, CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return obj->assignIfDuplicate(x0_);
}


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

    return CasADi::SX::setMaxNumCallsInPrint(x0_);
}


// ================== Static method: "setMaxNumCallsInPrint'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::setMaxNumCallsInPrint'"
// cWrapperName: "CasADi__SX__setMaxNumCallsInPrint_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__SX__setMaxNumCallsInPrint_TIC()"
// call: "CasADi::SX::setMaxNumCallsInPrint()"
extern "C"
    void CasADi__SX__setMaxNumCallsInPrint_TIC();
void CasADi__SX__setMaxNumCallsInPrint_TIC(){

    return CasADi::SX::setMaxNumCallsInPrint();
}


// ================== Static method: "getMaxNumCallsInPrint" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getMaxNumCallsInPrint"
// cWrapperName: "CasADi__SX__getMaxNumCallsInPrint"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CLong)
// cWrapperRetType: "long"
// proto: "long CasADi__SX__getMaxNumCallsInPrint()"
// call: "CasADi::SX::getMaxNumCallsInPrint()"
extern "C"
    long CasADi__SX__getMaxNumCallsInPrint();
long CasADi__SX__getMaxNumCallsInPrint(){

    return CasADi::SX::getMaxNumCallsInPrint();
}


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

    return CasADi::SX::setEqualityCheckingDepth(x0_);
}


// ================== Static method: "setEqualityCheckingDepth'" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::setEqualityCheckingDepth'"
// cWrapperName: "CasADi__SX__setEqualityCheckingDepth_TIC"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CVoid)
// cWrapperRetType: "void"
// proto: "void CasADi__SX__setEqualityCheckingDepth_TIC()"
// call: "CasADi::SX::setEqualityCheckingDepth()"
extern "C"
    void CasADi__SX__setEqualityCheckingDepth_TIC();
void CasADi__SX__setEqualityCheckingDepth_TIC(){

    return CasADi::SX::setEqualityCheckingDepth();
}


// ================== Static method: "getEqualityCheckingDepth" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::getEqualityCheckingDepth"
// cWrapperName: "CasADi__SX__getEqualityCheckingDepth"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec CInt)
// cWrapperRetType: "int"
// proto: "int CasADi__SX__getEqualityCheckingDepth()"
// call: "CasADi::SX::getEqualityCheckingDepth()"
extern "C"
    int CasADi__SX__getEqualityCheckingDepth();
int CasADi__SX__getEqualityCheckingDepth(){

    return CasADi::SX::getEqualityCheckingDepth();
}


// ================== Normal method: "isNull" ===============
// class: "CasADi::SX"
// cppName: "CasADi::SX::isNull"
// cWrapperName: "CasADi__SX__isNull"
// protoArgs: "(CasADi::SX* obj)"
// args: "()"
// rettype: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__SX__isNull(CasADi::SX* obj)"
// call: "obj->isNull()"
extern "C"
    bool* CasADi__SX__isNull(CasADi::SX* obj);
bool* CasADi__SX__isNull(CasADi::SX* obj){

    return new bool( obj->isNull() );
}


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

    return new CasADi::SX( CasADi::SX() );
}


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

    return new CasADi::SX( CasADi::SX(x0_) );
}


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

    return new CasADi::SX( CasADi::SX(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;
}
extern "C"
    void delete_std__vector_CasADi__CasadiMeta_(std::vector<CasADi::CasadiMeta* >* obj);
void delete_std__vector_CasADi__CasadiMeta_(std::vector<CasADi::CasadiMeta* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__CasadiMeta__(std::vector<std::vector<CasADi::CasadiMeta* > >* obj);
void delete_std__vector_std__vector_CasADi__CasadiMeta__(std::vector<std::vector<CasADi::CasadiMeta* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___(std::vector<std::vector<std::vector<CasADi::CasadiMeta* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___(std::vector<std::vector<std::vector<CasADi::CasadiMeta* > > >* obj){
    delete obj;
}

// ================== Static method: "getVersion" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getVersion"
// cWrapperName: "CasADi__CasadiMeta__getVersion"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getVersion() );
}


// ================== Static method: "getGitRevision" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getGitRevision"
// cWrapperName: "CasADi__CasadiMeta__getGitRevision"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getGitRevision() );
}


// ================== Static method: "getGitDescribe" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getGitDescribe"
// cWrapperName: "CasADi__CasadiMeta__getGitDescribe"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getGitDescribe() );
}


// ================== Static method: "getFeatureList" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getFeatureList"
// cWrapperName: "CasADi__CasadiMeta__getFeatureList"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getFeatureList() );
}


// ================== Static method: "getBuildType" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getBuildType"
// cWrapperName: "CasADi__CasadiMeta__getBuildType"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getBuildType() );
}


// ================== Static method: "getCompilerId" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getCompilerId"
// cWrapperName: "CasADi__CasadiMeta__getCompilerId"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getCompilerId() );
}


// ================== Static method: "getCompiler" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getCompiler"
// cWrapperName: "CasADi__CasadiMeta__getCompiler"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getCompiler() );
}


// ================== Static method: "getCompilerFlags" ===============
// class: "CasADi::CasadiMeta"
// cppName: "CasADi::CasadiMeta::getCompilerFlags"
// cWrapperName: "CasADi__CasadiMeta__getCompilerFlags"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec 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 new std::string( CasADi::CasadiMeta::getCompilerFlags() );
}


// ================== delete CasadiClass Functor===============
// classType: CasadiClass Functor
extern "C"
    void delete_CasADi__Functor(CasADi::Functor* obj);
void delete_CasADi__Functor(CasADi::Functor* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__Functor_(std::vector<CasADi::Functor* >* obj);
void delete_std__vector_CasADi__Functor_(std::vector<CasADi::Functor* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__Functor__(std::vector<std::vector<CasADi::Functor* > >* obj);
void delete_std__vector_std__vector_CasADi__Functor__(std::vector<std::vector<CasADi::Functor* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__Functor___(std::vector<std::vector<std::vector<CasADi::Functor* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__Functor___(std::vector<std::vector<std::vector<CasADi::Functor* > > >* obj){
    delete obj;
}

// ================== delete CasadiClass CustomFunction===============
// classType: CasadiClass CustomFunction
extern "C"
    void delete_CasADi__CustomFunction(CasADi::CustomFunction* obj);
void delete_CasADi__CustomFunction(CasADi::CustomFunction* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_CasADi__CustomFunction_(std::vector<CasADi::CustomFunction* >* obj);
void delete_std__vector_CasADi__CustomFunction_(std::vector<CasADi::CustomFunction* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_CasADi__CustomFunction__(std::vector<std::vector<CasADi::CustomFunction* > >* obj);
void delete_std__vector_std__vector_CasADi__CustomFunction__(std::vector<std::vector<CasADi::CustomFunction* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___(std::vector<std::vector<std::vector<CasADi::CustomFunction* > > >* obj);
void delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___(std::vector<std::vector<std::vector<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: Val (NonVec CBool)
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj)"
// call: "obj->checkNode()"
extern "C"
    bool* CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj);
bool* CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj){

    return new bool( obj->checkNode() );
}


// ================== Constructor method: "CustomFunction" ===============
// class: "CasADi::CustomFunction"
// cppName: "CasADi::CustomFunction"
// cWrapperName: "CasADi__CustomFunction__CustomFunction"
// protoArgs: "()"
// args: "()"
// rettype: Val (NonVec (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 new CasADi::CustomFunction( CasADi::CustomFunction() );
}


// ================== Constructor method: "CustomFunction'" ===============
// class: "CasADi::CustomFunction"
// cppName: "CasADi::CustomFunction"
// cWrapperName: "CasADi__CustomFunction__CustomFunction_TIC"
// protoArgs: "(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2)"
// args: "(x0_, x1_, x2_)"
// rettype: Val (NonVec (CasadiClass CustomFunction))
// cWrapperRetType: "CasADi::CustomFunction*"
// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2)"
// call: "CasADi::CustomFunction(x0_, x1_, x2_)"
extern "C"
    CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2);
CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2){
    CasADi::CustomEvaluate x0_ = Marshaling<CasADi::CustomEvaluate,CasADi::CustomEvaluate*>::marshal(x0);
    std::vector<CasADi::CRSSparsity > x1_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x1);
    std::vector<CasADi::CRSSparsity > x2_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x2);

    return new CasADi::CustomFunction( 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: Val (NonVec (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 x0_ = Marshaling<CasADi::CustomEvaluate,CasADi::CustomEvaluate*>::marshal(x0);

    return new CasADi::CustomFunction( CasADi::CustomFunction(x0_) );
}


// ================== function "CasADi::getSchemeEntryName" ===============
// cppName: "CasADi::getSchemeEntryName"
// cWrapperName: "CasADi__getSchemeEntryName"
// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"
// params: [Val (NonVec (CasadiEnum InputOutputScheme)),Val (NonVec 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 new std::string( CasADi::getSchemeEntryName(x0_, x1_) );
}


// ================== function "CasADi::getSchemeEntryDoc" ===============
// cppName: "CasADi::getSchemeEntryDoc"
// cWrapperName: "CasADi__getSchemeEntryDoc"
// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"
// params: [Val (NonVec (CasadiEnum InputOutputScheme)),Val (NonVec 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 new std::string( CasADi::getSchemeEntryDoc(x0_, x1_) );
}


// ================== function "CasADi::getSchemeEntryEnumName" ===============
// cppName: "CasADi::getSchemeEntryEnumName"
// cWrapperName: "CasADi__getSchemeEntryEnumName"
// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"
// params: [Val (NonVec (CasadiEnum InputOutputScheme)),Val (NonVec 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 new std::string( CasADi::getSchemeEntryEnumName(x0_, x1_) );
}


// ================== function "CasADi::getSchemeEntryEnum" ===============
// cppName: "CasADi::getSchemeEntryEnum"
// cWrapperName: "CasADi__getSchemeEntryEnum"
// protoArgs: "(CasADi::InputOutputScheme x0, std::string* x1)"
// params: [Val (NonVec (CasadiEnum InputOutputScheme)),ConstRef (NonVec 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 x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return CasADi::getSchemeEntryEnum(x0_, x1_);
}


// ================== function "CasADi::getSchemeSize" ===============
// cppName: "CasADi::getSchemeSize"
// cWrapperName: "CasADi__getSchemeSize"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// params: [Val (NonVec (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 CasADi::getSchemeSize(x0_);
}


// ================== function "CasADi::getSchemeName" ===============
// cppName: "CasADi::getSchemeName"
// cWrapperName: "CasADi__getSchemeName"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// params: [Val (NonVec (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 new std::string( CasADi::getSchemeName(x0_) );
}


// ================== function "CasADi::getSchemeEntryNames" ===============
// cppName: "CasADi::getSchemeEntryNames"
// cWrapperName: "CasADi__getSchemeEntryNames"
// protoArgs: "(CasADi::InputOutputScheme x0)"
// params: [Val (NonVec (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 new std::string( CasADi::getSchemeEntryNames(x0_) );
}


// ================== function "CasADi::complement" ===============
// cppName: "CasADi::complement"
// cWrapperName: "CasADi__complement"
// protoArgs: "(std::vector<int > * x0, int x1)"
// params: [ConstRef (Vec (NonVec CInt)),Val (NonVec 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 new std::vector<int >( CasADi::complement(x0_, x1_) );
}


// ================== function "CasADi::lookupvector" ===============
// cppName: "CasADi::lookupvector"
// cWrapperName: "CasADi__lookupvector"
// protoArgs: "(std::vector<int > * x0, int x1)"
// params: [ConstRef (Vec (NonVec CInt)),Val (NonVec 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 new std::vector<int >( CasADi::lookupvector(x0_, x1_) );
}


// ================== function "CasADi::isIncreasing" ===============
// cppName: "CasADi::isIncreasing"
// cWrapperName: "CasADi__isIncreasing"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isIncreasing(std::vector<int > * x0)"
// call: "CasADi::isIncreasing(x0_)"
extern "C"
    bool* CasADi__isIncreasing(std::vector<int > * x0);
bool* CasADi__isIncreasing(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isIncreasing(x0_) );
}


// ================== function "CasADi::isDecreasing" ===============
// cppName: "CasADi::isDecreasing"
// cWrapperName: "CasADi__isDecreasing"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isDecreasing(std::vector<int > * x0)"
// call: "CasADi::isDecreasing(x0_)"
extern "C"
    bool* CasADi__isDecreasing(std::vector<int > * x0);
bool* CasADi__isDecreasing(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isDecreasing(x0_) );
}


// ================== function "CasADi::isNonIncreasing" ===============
// cppName: "CasADi::isNonIncreasing"
// cWrapperName: "CasADi__isNonIncreasing"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isNonIncreasing(std::vector<int > * x0)"
// call: "CasADi::isNonIncreasing(x0_)"
extern "C"
    bool* CasADi__isNonIncreasing(std::vector<int > * x0);
bool* CasADi__isNonIncreasing(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isNonIncreasing(x0_) );
}


// ================== function "CasADi::isNonDecreasing" ===============
// cppName: "CasADi::isNonDecreasing"
// cWrapperName: "CasADi__isNonDecreasing"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isNonDecreasing(std::vector<int > * x0)"
// call: "CasADi::isNonDecreasing(x0_)"
extern "C"
    bool* CasADi__isNonDecreasing(std::vector<int > * x0);
bool* CasADi__isNonDecreasing(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isNonDecreasing(x0_) );
}


// ================== function "CasADi::isMonotone" ===============
// cppName: "CasADi::isMonotone"
// cWrapperName: "CasADi__isMonotone"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isMonotone(std::vector<int > * x0)"
// call: "CasADi::isMonotone(x0_)"
extern "C"
    bool* CasADi__isMonotone(std::vector<int > * x0);
bool* CasADi__isMonotone(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isMonotone(x0_) );
}


// ================== function "CasADi::isStrictlyMonotone" ===============
// cppName: "CasADi::isStrictlyMonotone"
// cWrapperName: "CasADi__isStrictlyMonotone"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isStrictlyMonotone(std::vector<int > * x0)"
// call: "CasADi::isStrictlyMonotone(x0_)"
extern "C"
    bool* CasADi__isStrictlyMonotone(std::vector<int > * x0);
bool* CasADi__isStrictlyMonotone(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isStrictlyMonotone(x0_) );
}


// ================== function "CasADi::isRegular" ===============
// cppName: "CasADi::isRegular"
// cWrapperName: "CasADi__isRegular"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isRegular(std::vector<int > * x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    bool* CasADi__isRegular(std::vector<int > * x0);
bool* CasADi__isRegular(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new bool( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::isIncreasing'" ===============
// cppName: "CasADi::isIncreasing'"
// cWrapperName: "CasADi__isIncreasing_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isIncreasing_TIC(std::vector<double > * x0)"
// call: "CasADi::isIncreasing(x0_)"
extern "C"
    bool* CasADi__isIncreasing_TIC(std::vector<double > * x0);
bool* CasADi__isIncreasing_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isIncreasing(x0_) );
}


// ================== function "CasADi::isDecreasing'" ===============
// cppName: "CasADi::isDecreasing'"
// cWrapperName: "CasADi__isDecreasing_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isDecreasing_TIC(std::vector<double > * x0)"
// call: "CasADi::isDecreasing(x0_)"
extern "C"
    bool* CasADi__isDecreasing_TIC(std::vector<double > * x0);
bool* CasADi__isDecreasing_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isDecreasing(x0_) );
}


// ================== function "CasADi::isNonIncreasing'" ===============
// cppName: "CasADi::isNonIncreasing'"
// cWrapperName: "CasADi__isNonIncreasing_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isNonIncreasing_TIC(std::vector<double > * x0)"
// call: "CasADi::isNonIncreasing(x0_)"
extern "C"
    bool* CasADi__isNonIncreasing_TIC(std::vector<double > * x0);
bool* CasADi__isNonIncreasing_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isNonIncreasing(x0_) );
}


// ================== function "CasADi::isNonDecreasing'" ===============
// cppName: "CasADi::isNonDecreasing'"
// cWrapperName: "CasADi__isNonDecreasing_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isNonDecreasing_TIC(std::vector<double > * x0)"
// call: "CasADi::isNonDecreasing(x0_)"
extern "C"
    bool* CasADi__isNonDecreasing_TIC(std::vector<double > * x0);
bool* CasADi__isNonDecreasing_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isNonDecreasing(x0_) );
}


// ================== function "CasADi::isMonotone'" ===============
// cppName: "CasADi::isMonotone'"
// cWrapperName: "CasADi__isMonotone_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isMonotone_TIC(std::vector<double > * x0)"
// call: "CasADi::isMonotone(x0_)"
extern "C"
    bool* CasADi__isMonotone_TIC(std::vector<double > * x0);
bool* CasADi__isMonotone_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isMonotone(x0_) );
}


// ================== function "CasADi::isStrictlyMonotone'" ===============
// cppName: "CasADi::isStrictlyMonotone'"
// cWrapperName: "CasADi__isStrictlyMonotone_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isStrictlyMonotone_TIC(std::vector<double > * x0)"
// call: "CasADi::isStrictlyMonotone(x0_)"
extern "C"
    bool* CasADi__isStrictlyMonotone_TIC(std::vector<double > * x0);
bool* CasADi__isStrictlyMonotone_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isStrictlyMonotone(x0_) );
}


// ================== function "CasADi::isRegular'" ===============
// cppName: "CasADi::isRegular'"
// cWrapperName: "CasADi__isRegular_TIC"
// protoArgs: "(std::vector<double > * x0)"
// params: [ConstRef (Vec (NonVec CDouble))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isRegular_TIC(std::vector<double > * x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    bool* CasADi__isRegular_TIC(std::vector<double > * x0);
bool* CasADi__isRegular_TIC(std::vector<double > * x0){
    std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);

    return new bool( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::isRegular'''" ===============
// cppName: "CasADi::isRegular'''"
// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isRegular_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    bool* CasADi__isRegular_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isRegular_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::trans'" ===============
// cppName: "CasADi::trans'"
// cWrapperName: "CasADi__trans_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__trans_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::trans(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__trans_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__trans_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::trans(x0_) );
}


// ================== function "CasADi::mul'''" ===============
// cppName: "CasADi::mul'''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::CRSSparsity* x2)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// 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::CRSSparsity* 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::CRSSparsity* x2);
CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::CRSSparsity* x2){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);
    CasADi::CRSSparsity x2_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x2);

    return new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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 (Vec (NonVec (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 new CasADi::Matrix< double >( CasADi::mul(x0_) );
}


// ================== function "CasADi::isConstant'" ===============
// cppName: "CasADi::isConstant'"
// cWrapperName: "CasADi__isConstant_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isConstant_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isConstant(x0_)"
extern "C"
    bool* CasADi__isConstant_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isConstant_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isConstant(x0_) );
}


// ================== function "CasADi::isDense'" ===============
// cppName: "CasADi::isDense'"
// cWrapperName: "CasADi__isDense_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isDense_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isDense(x0_)"
extern "C"
    bool* CasADi__isDense_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isDense_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isDense(x0_) );
}


// ================== function "CasADi::isEmpty'" ===============
// cppName: "CasADi::isEmpty'"
// cWrapperName: "CasADi__isEmpty_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isEmpty_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isEmpty(x0_)"
extern "C"
    bool* CasADi__isEmpty_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isEmpty_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isEmpty(x0_) );
}


// ================== function "CasADi::isInteger'" ===============
// cppName: "CasADi::isInteger'"
// cWrapperName: "CasADi__isInteger_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isInteger_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isInteger(x0_)"
extern "C"
    bool* CasADi__isInteger_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isInteger_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isInteger(x0_) );
}


// ================== function "CasADi::isScalar'" ===============
// cppName: "CasADi::isScalar'"
// cWrapperName: "CasADi__isScalar_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isScalar_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isScalar(x0_)"
extern "C"
    bool* CasADi__isScalar_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isScalar_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isScalar(x0_) );
}


// ================== function "CasADi::isVector'" ===============
// cppName: "CasADi::isVector'"
// cWrapperName: "CasADi__isVector_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isVector_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isVector(x0_)"
extern "C"
    bool* CasADi__isVector_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isVector_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isVector(x0_) );
}


// ================== function "CasADi::isTril'" ===============
// cppName: "CasADi::isTril'"
// cWrapperName: "CasADi__isTril_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isTril_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isTril(x0_)"
extern "C"
    bool* CasADi__isTril_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isTril_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isTril(x0_) );
}


// ================== function "CasADi::isTriu'" ===============
// cppName: "CasADi::isTriu'"
// cWrapperName: "CasADi__isTriu_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isTriu_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isTriu(x0_)"
extern "C"
    bool* CasADi__isTriu_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isTriu_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isTriu(x0_) );
}


// ================== function "CasADi::det'" ===============
// cppName: "CasADi::det'"
// cWrapperName: "CasADi__det_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::det(x0_);
}


// ================== function "CasADi::getMinor'" ===============
// cppName: "CasADi::getMinor'"
// cWrapperName: "CasADi__getMinor_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return 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 (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return CasADi::cofactor(x0_, x1_, x2_);
}


// ================== function "CasADi::adj'" ===============
// cppName: "CasADi::adj'"
// cWrapperName: "CasADi__adj_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::adj(x0_) );
}


// ================== function "CasADi::inv'" ===============
// cppName: "CasADi::inv'"
// cWrapperName: "CasADi__inv_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< double >( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::reshape'''" ===============
// cppName: "CasADi::reshape'''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec'" ===============
// cppName: "CasADi::vec'"
// cWrapperName: "CasADi__vec_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::vec(x0_) );
}


// ================== function "CasADi::flatten'" ===============
// cppName: "CasADi::flatten'"
// cWrapperName: "CasADi__flatten_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__flatten_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::flatten(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__flatten_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__flatten_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::flatten(x0_) );
}


// ================== function "CasADi::vecNZ'" ===============
// cppName: "CasADi::vecNZ'"
// cWrapperName: "CasADi__vecNZ_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::flattenNZ'" ===============
// cppName: "CasADi::flattenNZ'"
// cWrapperName: "CasADi__flattenNZ_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__flattenNZ_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::flattenNZ(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__flattenNZ_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__flattenNZ_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::flattenNZ(x0_) );
}


// ================== function "CasADi::blockcat'" ===============
// cppName: "CasADi::blockcat'"
// cWrapperName: "CasADi__blockcat_TIC"
// protoArgs: "(std::vector<std::vector<CasADi::Matrix< double >* > > * x0)"
// params: [ConstRef (Vec (Vec (NonVec (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 new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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 new std::vector<std::vector<CasADi::Matrix< double > > >( 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 (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new std::vector<std::vector<CasADi::Matrix< double > > >( 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 (NonVec (CasadiClass DMatrix)),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<std::vector<CasADi::Matrix< double > > >( 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 (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new std::vector<std::vector<CasADi::Matrix< double > > >( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::horzcat'" ===============
// cppName: "CasADi::horzcat'"
// cWrapperName: "CasADi__horzcat_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);

    return new std::vector<CasADi::Matrix< double > >( 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 (NonVec (CasadiClass DMatrix)),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<CasADi::Matrix< double > >( 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 (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new std::vector<CasADi::Matrix< double > >( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::vertcat'" ===============
// cppName: "CasADi::vertcat'"
// cWrapperName: "CasADi__vertcat_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);

    return new std::vector<CasADi::Matrix< double > >( 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 (NonVec (CasadiClass DMatrix)),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<CasADi::Matrix< double > >( 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 (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new std::vector<CasADi::Matrix< double > >( CasADi::vertsplit(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 (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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 (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::norm_1(x0_) );
}


// ================== function "CasADi::norm_2'" ===============
// cppName: "CasADi::norm_2'"
// cWrapperName: "CasADi__norm_2_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::norm_2(x0_) );
}


// ================== function "CasADi::norm_inf'" ===============
// cppName: "CasADi::norm_inf'"
// cWrapperName: "CasADi__norm_inf_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::norm_F'" ===============
// cppName: "CasADi::norm_F'"
// cWrapperName: "CasADi__norm_F_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),Ref (NonVec (CasadiClass DMatrix)),Ref (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return CasADi::qr(x0_, x1_, x2_);
}


// ================== function "CasADi::nullspace'" ===============
// cppName: "CasADi::nullspace'"
// cWrapperName: "CasADi__nullspace_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::solve'" ===============
// cppName: "CasADi::solve'"
// cWrapperName: "CasADi__solve_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::solve(x0_, x1_) );
}


// ================== function "CasADi::pinv'" ===============
// cppName: "CasADi::pinv'"
// cWrapperName: "CasADi__pinv_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::pinv(x0_) );
}


// ================== function "CasADi::isZero'" ===============
// cppName: "CasADi::isZero'"
// cWrapperName: "CasADi__isZero_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isZero_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isZero(x0_)"
extern "C"
    bool* CasADi__isZero_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isZero_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isZero(x0_) );
}


// ================== function "CasADi::isOne'" ===============
// cppName: "CasADi::isOne'"
// cWrapperName: "CasADi__isOne_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isOne_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isOne(x0_)"
extern "C"
    bool* CasADi__isOne_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isOne_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isOne(x0_) );
}


// ================== function "CasADi::isMinusOne'" ===============
// cppName: "CasADi::isMinusOne'"
// cWrapperName: "CasADi__isMinusOne_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isMinusOne_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isMinusOne(x0_)"
extern "C"
    bool* CasADi__isMinusOne_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isMinusOne_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isMinusOne(x0_) );
}


// ================== function "CasADi::isIdentity'" ===============
// cppName: "CasADi::isIdentity'"
// cWrapperName: "CasADi__isIdentity_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isIdentity_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::isIdentity(x0_)"
extern "C"
    bool* CasADi__isIdentity_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__isIdentity_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::isIdentity(x0_) );
}


// ================== function "CasADi::nnz'" ===============
// cppName: "CasADi::nnz'"
// cWrapperName: "CasADi__nnz_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__nnz_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::nnz(x0_)"
extern "C"
    int CasADi__nnz_TIC(CasADi::Matrix< double >* x0);
int CasADi__nnz_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::nnz(x0_);
}


// ================== function "CasADi::nnz_sym'" ===============
// cppName: "CasADi::nnz_sym'"
// cWrapperName: "CasADi__nnz_sym_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__nnz_sym_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::nnz_sym(x0_)"
extern "C"
    int CasADi__nnz_sym_TIC(CasADi::Matrix< double >* x0);
int CasADi__nnz_sym_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::nnz_sym(x0_);
}


// ================== function "CasADi::isEqual'" ===============
// cppName: "CasADi::isEqual'"
// cWrapperName: "CasADi__isEqual_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isEqual_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    bool* CasADi__isEqual_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);
bool* CasADi__isEqual_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new bool( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::repmat'" ===============
// cppName: "CasADi::repmat'"
// cWrapperName: "CasADi__repmat_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< double >( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::getSparseTriplet'" ===============
// cppName: "CasADi::getSparseTriplet'"
// cWrapperName: "CasADi__getSparseTriplet_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<std::vector<int > >*"
// proto: "std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::getSparseTriplet(x0_)"
extern "C"
    std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0);
std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new std::vector<std::vector<int > >( CasADi::getSparseTriplet(x0_) );
}


// ================== function "CasADi::unite'" ===============
// cppName: "CasADi::unite'"
// cWrapperName: "CasADi__unite_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::sumCols'" ===============
// cppName: "CasADi::sumCols'"
// cWrapperName: "CasADi__sumCols_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumRows'" ===============
// cppName: "CasADi::sumRows'"
// cWrapperName: "CasADi__sumRows_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumAll'" ===============
// cppName: "CasADi::sumAll'"
// cWrapperName: "CasADi__sumAll_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::trace'" ===============
// cppName: "CasADi::trace'"
// cWrapperName: "CasADi__trace_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::trace(x0_);
}


// ================== function "CasADi::makeDense'" ===============
// cppName: "CasADi::makeDense'"
// cWrapperName: "CasADi__makeDense_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [Ref (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeDense_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::makeDense(x0_)"
extern "C"
    void CasADi__makeDense_TIC(CasADi::Matrix< double >* x0);
void CasADi__makeDense_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::makeDense(x0_);
}


// ================== function "CasADi::densify'" ===============
// cppName: "CasADi::densify'"
// cWrapperName: "CasADi__densify_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__densify_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::densify(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__densify_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__densify_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::densify(x0_) );
}


// ================== function "CasADi::makeSparse''" ===============
// cppName: "CasADi::makeSparse''"
// cWrapperName: "CasADi__makeSparse_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, double x1)"
// params: [Ref (NonVec (CasadiClass DMatrix)),Val (NonVec CDouble)]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeSparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1)"
// call: "CasADi::makeSparse(x0_, x1_)"
extern "C"
    void CasADi__makeSparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1);
void CasADi__makeSparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return CasADi::makeSparse(x0_, x1_);
}


// ================== function "CasADi::makeSparse'''" ===============
// cppName: "CasADi::makeSparse'''"
// cWrapperName: "CasADi__makeSparse_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [Ref (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeSparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::makeSparse(x0_)"
extern "C"
    void CasADi__makeSparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
void CasADi__makeSparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::makeSparse(x0_);
}


// ================== function "CasADi::hasNonStructuralZeros'" ===============
// cppName: "CasADi::hasNonStructuralZeros'"
// cWrapperName: "CasADi__hasNonStructuralZeros_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__hasNonStructuralZeros_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::hasNonStructuralZeros(x0_)"
extern "C"
    bool* CasADi__hasNonStructuralZeros_TIC(CasADi::Matrix< double >* x0);
bool* CasADi__hasNonStructuralZeros_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new bool( CasADi::hasNonStructuralZeros(x0_) );
}


// ================== function "CasADi::diag'" ===============
// cppName: "CasADi::diag'"
// cWrapperName: "CasADi__diag_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag'" ===============
// cppName: "CasADi::blkdiag'"
// cWrapperName: "CasADi__blkdiag_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::Matrix< double >( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::polyval'" ===============
// cppName: "CasADi::polyval'"
// cWrapperName: "CasADi__polyval_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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, bool* x3)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CDouble)),Ref (Vec (NonVec CDouble)),Val (NonVec 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, bool* 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, bool* x3);
void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2, bool* x3){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,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,bool*>::marshal(x3);

    return 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 (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CDouble)),Ref (Vec (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,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);

    return CasADi::addMultiple(x0_, x1_, x2_);
}


// ================== function "CasADi::veccat'" ===============
// cppName: "CasADi::veccat'"
// cWrapperName: "CasADi__veccat_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::Matrix< double >( CasADi::veccat(x0_) );
}


// ================== function "CasADi::vecNZcat'" ===============
// cppName: "CasADi::vecNZcat'"
// cWrapperName: "CasADi__vecNZcat_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::Matrix< double >( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::flattencat'" ===============
// cppName: "CasADi::flattencat'"
// cWrapperName: "CasADi__flattencat_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"
// call: "CasADi::flattencat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector<CasADi::Matrix< double >* > * x0);
CasADi::Matrix< double >* CasADi__flattencat_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 new CasADi::Matrix< double >( CasADi::flattencat(x0_) );
}


// ================== function "CasADi::flattenNZcat'" ===============
// cppName: "CasADi::flattenNZcat'"
// cWrapperName: "CasADi__flattenNZcat_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"
// call: "CasADi::flattenNZcat(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0);
CasADi::Matrix< double >* CasADi__flattenNZcat_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 new CasADi::Matrix< double >( CasADi::flattenNZcat(x0_) );
}


// ================== function "CasADi::project'" ===============
// cppName: "CasADi::project'"
// cWrapperName: "CasADi__project_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::project(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::project(x0_, x1_) );
}


// ================== function "CasADi::sprank'" ===============
// cppName: "CasADi::sprank'"
// cWrapperName: "CasADi__sprank_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return CasADi::sprank(x0_);
}


// ================== function "CasADi::kron'" ===============
// cppName: "CasADi::kron'"
// cWrapperName: "CasADi__kron_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::sparse''" ===============
// cppName: "CasADi::sparse''"
// cWrapperName: "CasADi__sparse_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0, double x1)"
// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec 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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::sparse(x0_, x1_) );
}


// ================== function "CasADi::sparse'''" ===============
// cppName: "CasADi::sparse'''"
// cWrapperName: "CasADi__sparse_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::sparse(x0_) );
}


// ================== function "CasADi::full'" ===============
// cppName: "CasADi::full'"
// cWrapperName: "CasADi__full_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__full_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::full(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__full_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< double >* CasADi__full_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::full(x0_) );
}


// ================== function "CasADi::trans''" ===============
// cppName: "CasADi::trans''"
// cWrapperName: "CasADi__trans_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__trans_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::trans(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__trans_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__trans_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::trans(x0_) );
}


// ================== function "CasADi::mul''''''" ===============
// cppName: "CasADi::mul''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2)"
// call: "CasADi::mul(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2);
CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::CRSSparsity x2_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( 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::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( 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::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::mul(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::mul(x0_) );
}


// ================== function "CasADi::isConstant''" ===============
// cppName: "CasADi::isConstant''"
// cWrapperName: "CasADi__isConstant_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isConstant_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isConstant(x0_)"
extern "C"
    bool* CasADi__isConstant_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isConstant_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isConstant(x0_) );
}


// ================== function "CasADi::isDense''" ===============
// cppName: "CasADi::isDense''"
// cWrapperName: "CasADi__isDense_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isDense(x0_)"
extern "C"
    bool* CasADi__isDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isDense(x0_) );
}


// ================== function "CasADi::isEmpty''" ===============
// cppName: "CasADi::isEmpty''"
// cWrapperName: "CasADi__isEmpty_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isEmpty_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isEmpty(x0_)"
extern "C"
    bool* CasADi__isEmpty_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isEmpty_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isEmpty(x0_) );
}


// ================== function "CasADi::isInteger''" ===============
// cppName: "CasADi::isInteger''"
// cWrapperName: "CasADi__isInteger_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isInteger_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isInteger(x0_)"
extern "C"
    bool* CasADi__isInteger_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isInteger_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isInteger(x0_) );
}


// ================== function "CasADi::isScalar''" ===============
// cppName: "CasADi::isScalar''"
// cWrapperName: "CasADi__isScalar_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isScalar_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isScalar(x0_)"
extern "C"
    bool* CasADi__isScalar_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isScalar_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isScalar(x0_) );
}


// ================== function "CasADi::isVector''" ===============
// cppName: "CasADi::isVector''"
// cWrapperName: "CasADi__isVector_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isVector_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isVector(x0_)"
extern "C"
    bool* CasADi__isVector_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isVector_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isVector(x0_) );
}


// ================== function "CasADi::isTril''" ===============
// cppName: "CasADi::isTril''"
// cWrapperName: "CasADi__isTril_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isTril_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isTril(x0_)"
extern "C"
    bool* CasADi__isTril_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isTril_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isTril(x0_) );
}


// ================== function "CasADi::isTriu''" ===============
// cppName: "CasADi::isTriu''"
// cWrapperName: "CasADi__isTriu_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isTriu_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isTriu(x0_)"
extern "C"
    bool* CasADi__isTriu_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isTriu_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isTriu(x0_) );
}


// ================== function "CasADi::det''" ===============
// cppName: "CasADi::det''"
// cWrapperName: "CasADi__det_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::det(x0_)"
extern "C"
    CasADi::SX* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::SX* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::SX( CasADi::det(x0_) );
}


// ================== function "CasADi::getMinor''" ===============
// cppName: "CasADi::getMinor''"
// cWrapperName: "CasADi__getMinor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::getMinor(x0_, x1_, x2_)"
extern "C"
    CasADi::SX* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
CasADi::SX* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::SX( CasADi::getMinor(x0_, x1_, x2_) );
}


// ================== function "CasADi::cofactor''" ===============
// cppName: "CasADi::cofactor''"
// cWrapperName: "CasADi__cofactor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::cofactor(x0_, x1_, x2_)"
extern "C"
    CasADi::SX* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
CasADi::SX* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::SX( CasADi::cofactor(x0_, x1_, x2_) );
}


// ================== function "CasADi::adj''" ===============
// cppName: "CasADi::adj''"
// cWrapperName: "CasADi__adj_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::adj(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::adj(x0_) );
}


// ================== function "CasADi::inv''" ===============
// cppName: "CasADi::inv''"
// cWrapperName: "CasADi__inv_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::inv(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::inv(x0_) );
}


// ================== function "CasADi::reshape''''" ===============
// cppName: "CasADi::reshape''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::reshape(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::reshape'''''" ===============
// cppName: "CasADi::reshape'''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec''" ===============
// cppName: "CasADi::vec''"
// cWrapperName: "CasADi__vec_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::vec(x0_) );
}


// ================== function "CasADi::flatten''" ===============
// cppName: "CasADi::flatten''"
// cWrapperName: "CasADi__flatten_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flatten_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::flatten(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__flatten_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__flatten_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::flatten(x0_) );
}


// ================== function "CasADi::vecNZ''" ===============
// cppName: "CasADi::vecNZ''"
// cWrapperName: "CasADi__vecNZ_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::vecNZ(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::flattenNZ''" ===============
// cppName: "CasADi::flattenNZ''"
// cWrapperName: "CasADi__flattenNZ_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flattenNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::flattenNZ(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__flattenNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__flattenNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::flattenNZ(x0_) );
}


// ================== function "CasADi::blockcat''" ===============
// cppName: "CasADi::blockcat''"
// cWrapperName: "CasADi__blockcat_TIC_TIC"
// protoArgs: "(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0)"
// params: [ConstRef (Vec (Vec (NonVec (CasadiClass SXMatrix))))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0)"
// call: "CasADi::blockcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0){
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > > x0_ = Marshaling<std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >,std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::blockcat(x0_) );
}


// ================== function "CasADi::blocksplit''''''''" ===============
// cppName: "CasADi::blocksplit''''''''"
// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"
// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2);
std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);
    std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);

    return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( 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::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"
// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::blocksplit(x0_, x1_, x2_)"
extern "C"
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( 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::SX >* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"
// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::blocksplit(x0_, x1_)"
extern "C"
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);
std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( 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::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"
// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::blocksplit(x0_)"
extern "C"
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::horzcat''" ===============
// cppName: "CasADi::horzcat''"
// cWrapperName: "CasADi__horzcat_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::horzsplit''''''" ===============
// cppName: "CasADi::horzsplit''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt))]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit'''''''" ===============
// cppName: "CasADi::horzsplit'''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::horzsplit(x0_, x1_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( 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::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::horzsplit(x0_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::vertcat''" ===============
// cppName: "CasADi::vertcat''"
// cWrapperName: "CasADi__vertcat_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::vertsplit''''''" ===============
// cppName: "CasADi::vertsplit''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt))]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit'''''''" ===============
// cppName: "CasADi::vertsplit'''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::vertsplit(x0_, x1_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( 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::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::vertsplit(x0_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::vertsplit(x0_) );
}


// ================== function "CasADi::inner_prod''" ===============
// cppName: "CasADi::inner_prod''"
// cWrapperName: "CasADi__inner_prod_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::inner_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::inner_prod(x0_, x1_) );
}


// ================== function "CasADi::outer_prod''" ===============
// cppName: "CasADi::outer_prod''"
// cWrapperName: "CasADi__outer_prod_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::outer_prod(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::outer_prod(x0_, x1_) );
}


// ================== function "CasADi::norm_1''" ===============
// cppName: "CasADi::norm_1''"
// cWrapperName: "CasADi__norm_1_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::norm_1(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::norm_1(x0_) );
}


// ================== function "CasADi::norm_2''" ===============
// cppName: "CasADi::norm_2''"
// cWrapperName: "CasADi__norm_2_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::norm_2(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::norm_2(x0_) );
}


// ================== function "CasADi::norm_inf''" ===============
// cppName: "CasADi::norm_inf''"
// cWrapperName: "CasADi__norm_inf_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::norm_inf(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::norm_F''" ===============
// cppName: "CasADi::norm_F''"
// cWrapperName: "CasADi__norm_F_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::norm_F(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::norm_F(x0_) );
}


// ================== function "CasADi::qr''" ===============
// cppName: "CasADi::qr''"
// cWrapperName: "CasADi__qr_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::qr(x0_, x1_, x2_)"
extern "C"
    void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return CasADi::qr(x0_, x1_, x2_);
}


// ================== function "CasADi::nullspace''" ===============
// cppName: "CasADi::nullspace''"
// cWrapperName: "CasADi__nullspace_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::nullspace(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::solve''" ===============
// cppName: "CasADi::solve''"
// cWrapperName: "CasADi__solve_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::solve(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::solve(x0_, x1_) );
}


// ================== function "CasADi::pinv''" ===============
// cppName: "CasADi::pinv''"
// cWrapperName: "CasADi__pinv_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::pinv(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::pinv(x0_) );
}


// ================== function "CasADi::isZero''" ===============
// cppName: "CasADi::isZero''"
// cWrapperName: "CasADi__isZero_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isZero_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isZero(x0_)"
extern "C"
    bool* CasADi__isZero_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isZero_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isZero(x0_) );
}


// ================== function "CasADi::isOne''" ===============
// cppName: "CasADi::isOne''"
// cWrapperName: "CasADi__isOne_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isOne(x0_)"
extern "C"
    bool* CasADi__isOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isOne(x0_) );
}


// ================== function "CasADi::isMinusOne''" ===============
// cppName: "CasADi::isMinusOne''"
// cWrapperName: "CasADi__isMinusOne_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isMinusOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isMinusOne(x0_)"
extern "C"
    bool* CasADi__isMinusOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isMinusOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isMinusOne(x0_) );
}


// ================== function "CasADi::isIdentity''" ===============
// cppName: "CasADi::isIdentity''"
// cWrapperName: "CasADi__isIdentity_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isIdentity_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isIdentity(x0_)"
extern "C"
    bool* CasADi__isIdentity_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isIdentity_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isIdentity(x0_) );
}


// ================== function "CasADi::nnz''" ===============
// cppName: "CasADi::nnz''"
// cWrapperName: "CasADi__nnz_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__nnz_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::nnz(x0_)"
extern "C"
    int CasADi__nnz_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
int CasADi__nnz_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::nnz(x0_);
}


// ================== function "CasADi::nnz_sym''" ===============
// cppName: "CasADi::nnz_sym''"
// cWrapperName: "CasADi__nnz_sym_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__nnz_sym_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::nnz_sym(x0_)"
extern "C"
    int CasADi__nnz_sym_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
int CasADi__nnz_sym_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::nnz_sym(x0_);
}


// ================== function "CasADi::isEqual''" ===============
// cppName: "CasADi::isEqual''"
// cWrapperName: "CasADi__isEqual_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isEqual_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    bool* CasADi__isEqual_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
bool* CasADi__isEqual_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new bool( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::repmat''" ===============
// cppName: "CasADi::repmat''"
// cWrapperName: "CasADi__repmat_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::repmat(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
CasADi::Matrix< CasADi::SX >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::getSparseTriplet''" ===============
// cppName: "CasADi::getSparseTriplet''"
// cWrapperName: "CasADi__getSparseTriplet_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<std::vector<int > >*"
// proto: "std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::getSparseTriplet(x0_)"
extern "C"
    std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new std::vector<std::vector<int > >( CasADi::getSparseTriplet(x0_) );
}


// ================== function "CasADi::unite''" ===============
// cppName: "CasADi::unite''"
// cWrapperName: "CasADi__unite_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::unite(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::sumCols''" ===============
// cppName: "CasADi::sumCols''"
// cWrapperName: "CasADi__sumCols_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::sumCols(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumRows''" ===============
// cppName: "CasADi::sumRows''"
// cWrapperName: "CasADi__sumRows_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::sumRows(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumAll''" ===============
// cppName: "CasADi::sumAll''"
// cWrapperName: "CasADi__sumAll_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::sumAll(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::trace''" ===============
// cppName: "CasADi::trace''"
// cWrapperName: "CasADi__trace_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::trace(x0_)"
extern "C"
    CasADi::SX* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::SX* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::SX( CasADi::trace(x0_) );
}


// ================== function "CasADi::makeDense''" ===============
// cppName: "CasADi::makeDense''"
// cWrapperName: "CasADi__makeDense_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::makeDense(x0_)"
extern "C"
    void CasADi__makeDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
void CasADi__makeDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::makeDense(x0_);
}


// ================== function "CasADi::densify''" ===============
// cppName: "CasADi::densify''"
// cWrapperName: "CasADi__densify_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__densify_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::densify(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__densify_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__densify_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::densify(x0_) );
}


// ================== function "CasADi::makeSparse''''" ===============
// cppName: "CasADi::makeSparse''''"
// cWrapperName: "CasADi__makeSparse_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, double x1)"
// params: [Ref (NonVec (CasadiClass SXMatrix)),Val (NonVec CDouble)]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeSparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1)"
// call: "CasADi::makeSparse(x0_, x1_)"
extern "C"
    void CasADi__makeSparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1);
void CasADi__makeSparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return CasADi::makeSparse(x0_, x1_);
}


// ================== function "CasADi::makeSparse'''''" ===============
// cppName: "CasADi::makeSparse'''''"
// cWrapperName: "CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::makeSparse(x0_)"
extern "C"
    void CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
void CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::makeSparse(x0_);
}


// ================== function "CasADi::hasNonStructuralZeros''" ===============
// cppName: "CasADi::hasNonStructuralZeros''"
// cWrapperName: "CasADi__hasNonStructuralZeros_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__hasNonStructuralZeros_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::hasNonStructuralZeros(x0_)"
extern "C"
    bool* CasADi__hasNonStructuralZeros_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__hasNonStructuralZeros_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::hasNonStructuralZeros(x0_) );
}


// ================== function "CasADi::diag''" ===============
// cppName: "CasADi::diag''"
// cWrapperName: "CasADi__diag_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::diag(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag''" ===============
// cppName: "CasADi::blkdiag''"
// cWrapperName: "CasADi__blkdiag_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::polyval''" ===============
// cppName: "CasADi::polyval''"
// cWrapperName: "CasADi__polyval_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::polyval(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::polyval(x0_, x1_) );
}


// ================== function "CasADi::addMultiple''''" ===============
// cppName: "CasADi::addMultiple''''"
// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Val (NonVec CBool)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3)"
// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3);
void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,bool*>::marshal(x3);

    return CasADi::addMultiple(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::addMultiple'''''" ===============
// cppName: "CasADi::addMultiple'''''"
// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX)))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"
// call: "CasADi::addMultiple(x0_, x1_, x2_)"
extern "C"
    void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2);
void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);

    return CasADi::addMultiple(x0_, x1_, x2_);
}


// ================== function "CasADi::veccat''" ===============
// cppName: "CasADi::veccat''"
// cWrapperName: "CasADi__veccat_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::veccat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::veccat(x0_) );
}


// ================== function "CasADi::vecNZcat''" ===============
// cppName: "CasADi::vecNZcat''"
// cWrapperName: "CasADi__vecNZcat_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::vecNZcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::flattencat''" ===============
// cppName: "CasADi::flattencat''"
// cWrapperName: "CasADi__flattencat_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::flattencat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::flattencat(x0_) );
}


// ================== function "CasADi::flattenNZcat''" ===============
// cppName: "CasADi::flattenNZcat''"
// cWrapperName: "CasADi__flattenNZcat_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"
// call: "CasADi::flattenNZcat(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);
CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::flattenNZcat(x0_) );
}


// ================== function "CasADi::project''" ===============
// cppName: "CasADi::project''"
// cWrapperName: "CasADi__project_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::project(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< CasADi::SX >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::project(x0_, x1_) );
}


// ================== function "CasADi::sprank''" ===============
// cppName: "CasADi::sprank''"
// cWrapperName: "CasADi__sprank_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::sprank(x0_)"
extern "C"
    int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::sprank(x0_);
}


// ================== function "CasADi::kron''" ===============
// cppName: "CasADi::kron''"
// cWrapperName: "CasADi__kron_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::kron(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::sparse''''" ===============
// cppName: "CasADi::sparse''''"
// cWrapperName: "CasADi__sparse_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, double x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CDouble)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1)"
// call: "CasADi::sparse(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1);
CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    double x1_ = Marshaling<double,double>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::sparse(x0_, x1_) );
}


// ================== function "CasADi::sparse'''''" ===============
// cppName: "CasADi::sparse'''''"
// cWrapperName: "CasADi__sparse_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::sparse(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::sparse(x0_) );
}


// ================== function "CasADi::full''" ===============
// cppName: "CasADi::full''"
// cWrapperName: "CasADi__full_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__full_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::full(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__full_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__full_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::full(x0_) );
}


// ================== function "CasADi::logic_and" ===============
// cppName: "CasADi::logic_and"
// cWrapperName: "CasADi__logic_and"
// protoArgs: "(int* x0, int* x1)"
// params: [ConstRef (NonVec CInt),ConstRef (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__logic_and(int* x0, int* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    int CasADi__logic_and(int* x0, int* x1);
int CasADi__logic_and(int* x0, int* x1){
    int x0_ = Marshaling<int,int*>::marshal(x0);
    int x1_ = Marshaling<int,int*>::marshal(x1);

    return CasADi::logic_and(x0_, x1_);
}


// ================== function "CasADi::logic_or" ===============
// cppName: "CasADi::logic_or"
// cWrapperName: "CasADi__logic_or"
// protoArgs: "(int* x0, int* x1)"
// params: [ConstRef (NonVec CInt),ConstRef (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__logic_or(int* x0, int* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    int CasADi__logic_or(int* x0, int* x1);
int CasADi__logic_or(int* x0, int* x1){
    int x0_ = Marshaling<int,int*>::marshal(x0);
    int x1_ = Marshaling<int,int*>::marshal(x1);

    return CasADi::logic_or(x0_, x1_);
}


// ================== function "CasADi::logic_not" ===============
// cppName: "CasADi::logic_not"
// cWrapperName: "CasADi__logic_not"
// protoArgs: "(int* x0)"
// params: [ConstRef (NonVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__logic_not(int* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    int CasADi__logic_not(int* x0);
int CasADi__logic_not(int* x0){
    int x0_ = Marshaling<int,int*>::marshal(x0);

    return CasADi::logic_not(x0_);
}


// ================== function "CasADi::logic_and'" ===============
// cppName: "CasADi::logic_and'"
// cWrapperName: "CasADi__logic_and_TIC"
// protoArgs: "(double* x0, double* x1)"
// params: [ConstRef (NonVec CDouble),ConstRef (NonVec CDouble)]
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double CasADi__logic_and_TIC(double* x0, double* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    double CasADi__logic_and_TIC(double* x0, double* x1);
double CasADi__logic_and_TIC(double* x0, double* x1){
    double x0_ = Marshaling<double,double*>::marshal(x0);
    double x1_ = Marshaling<double,double*>::marshal(x1);

    return CasADi::logic_and(x0_, x1_);
}


// ================== function "CasADi::logic_or'" ===============
// cppName: "CasADi::logic_or'"
// cWrapperName: "CasADi__logic_or_TIC"
// protoArgs: "(double* x0, double* x1)"
// params: [ConstRef (NonVec CDouble),ConstRef (NonVec CDouble)]
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double CasADi__logic_or_TIC(double* x0, double* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    double CasADi__logic_or_TIC(double* x0, double* x1);
double CasADi__logic_or_TIC(double* x0, double* x1){
    double x0_ = Marshaling<double,double*>::marshal(x0);
    double x1_ = Marshaling<double,double*>::marshal(x1);

    return CasADi::logic_or(x0_, x1_);
}


// ================== function "CasADi::logic_not'" ===============
// cppName: "CasADi::logic_not'"
// cWrapperName: "CasADi__logic_not_TIC"
// protoArgs: "(double* x0)"
// params: [ConstRef (NonVec CDouble)]
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double CasADi__logic_not_TIC(double* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    double CasADi__logic_not_TIC(double* x0);
double CasADi__logic_not_TIC(double* x0){
    double x0_ = Marshaling<double,double*>::marshal(x0);

    return 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 (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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 (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( 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 (NonVec (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 > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and''''" ===============
// cppName: "CasADi::logic_and''''"
// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( 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::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( 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::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( 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 (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::logic_and''''''" ===============
// cppName: "CasADi::logic_and''''''"
// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SX* x0, CasADi::SX* x1)"
// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (NonVec (CasadiClass SX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1)"
// call: "CasADi::logic_and(x0_, x1_)"
extern "C"
    CasADi::SX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1);
CasADi::SX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);

    return new CasADi::SX( 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::SX* x0, CasADi::SX* x1)"
// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (NonVec (CasadiClass SX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1)"
// call: "CasADi::logic_or(x0_, x1_)"
extern "C"
    CasADi::SX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1);
CasADi::SX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);

    return new CasADi::SX( 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::SX* x0)"
// params: [ConstRef (NonVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SX*"
// proto: "CasADi::SX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0)"
// call: "CasADi::logic_not(x0_)"
extern "C"
    CasADi::SX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0);
CasADi::SX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new CasADi::SX( CasADi::logic_not(x0_) );
}


// ================== function "CasADi::hash_combine" ===============
// cppName: "CasADi::hash_combine"
// cWrapperName: "CasADi__hash_combine"
// protoArgs: "(size_t* x0, std::vector<int > * x1)"
// params: [Ref (NonVec CSize),ConstRef (Vec (NonVec 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);

    return 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: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec 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 CasADi::hash_sparsity(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::sp_dense" ===============
// cppName: "CasADi::sp_dense"
// cWrapperName: "CasADi__sp_dense"
// protoArgs: "(int x0, int x1)"
// params: [Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_dense(int x0, int x1)"
// call: "CasADi::sp_dense(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_dense(int x0, int x1);
CasADi::CRSSparsity* CasADi__sp_dense(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::sp_dense(x0_, x1_) );
}


// ================== function "CasADi::sp_dense'" ===============
// cppName: "CasADi::sp_dense'"
// cWrapperName: "CasADi__sp_dense_TIC"
// protoArgs: "(int x0)"
// params: [Val (NonVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_dense_TIC(int x0)"
// call: "CasADi::sp_dense(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_dense_TIC(int x0);
CasADi::CRSSparsity* CasADi__sp_dense_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::sp_dense(x0_) );
}


// ================== function "CasADi::sp_sparse" ===============
// cppName: "CasADi::sp_sparse"
// cWrapperName: "CasADi__sp_sparse"
// protoArgs: "(int x0, int x1)"
// params: [Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_sparse(int x0, int x1)"
// call: "CasADi::sp_sparse(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_sparse(int x0, int x1);
CasADi::CRSSparsity* CasADi__sp_sparse(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::sp_sparse(x0_, x1_) );
}


// ================== function "CasADi::sp_sparse'" ===============
// cppName: "CasADi::sp_sparse'"
// cWrapperName: "CasADi__sp_sparse_TIC"
// protoArgs: "(int x0)"
// params: [Val (NonVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_sparse_TIC(int x0)"
// call: "CasADi::sp_sparse(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_sparse_TIC(int x0);
CasADi::CRSSparsity* CasADi__sp_sparse_TIC(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::sp_sparse(x0_) );
}


// ================== function "CasADi::sp_unit" ===============
// cppName: "CasADi::sp_unit"
// cWrapperName: "CasADi__sp_unit"
// protoArgs: "(int x0, int x1)"
// params: [Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_unit(int x0, int x1)"
// call: "CasADi::sp_unit(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_unit(int x0, int x1);
CasADi::CRSSparsity* CasADi__sp_unit(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::sp_unit(x0_, x1_) );
}


// ================== function "CasADi::sp_tril" ===============
// cppName: "CasADi::sp_tril"
// cWrapperName: "CasADi__sp_tril"
// protoArgs: "(int x0)"
// params: [Val (NonVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_tril(int x0)"
// call: "CasADi::sp_tril(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_tril(int x0);
CasADi::CRSSparsity* CasADi__sp_tril(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::sp_tril(x0_) );
}


// ================== function "CasADi::sp_diag" ===============
// cppName: "CasADi::sp_diag"
// cWrapperName: "CasADi__sp_diag"
// protoArgs: "(int x0)"
// params: [Val (NonVec CInt)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_diag(int x0)"
// call: "CasADi::sp_diag(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_diag(int x0);
CasADi::CRSSparsity* CasADi__sp_diag(int x0){
    int x0_ = Marshaling<int,int>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::sp_diag(x0_) );
}


// ================== function "CasADi::sp_band" ===============
// cppName: "CasADi::sp_band"
// cWrapperName: "CasADi__sp_band"
// protoArgs: "(int x0, int x1)"
// params: [Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_band(int x0, int x1)"
// call: "CasADi::sp_band(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_band(int x0, int x1);
CasADi::CRSSparsity* CasADi__sp_band(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::sp_band(x0_, x1_) );
}


// ================== function "CasADi::sp_banded" ===============
// cppName: "CasADi::sp_banded"
// cWrapperName: "CasADi__sp_banded"
// protoArgs: "(int x0, int x1)"
// params: [Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_banded(int x0, int x1)"
// call: "CasADi::sp_banded(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_banded(int x0, int x1);
CasADi::CRSSparsity* CasADi__sp_banded(int x0, int x1){
    int x0_ = Marshaling<int,int>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::sp_banded(x0_, x1_) );
}


// ================== function "CasADi::sp_rowcol" ===============
// cppName: "CasADi::sp_rowcol"
// cWrapperName: "CasADi__sp_rowcol"
// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3)"
// params: [ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3)"
// call: "CasADi::sp_rowcol(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3);
CasADi::CRSSparsity* CasADi__sp_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 new CasADi::CRSSparsity( CasADi::sp_rowcol(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::getNZDense" ===============
// cppName: "CasADi::getNZDense"
// cWrapperName: "CasADi__getNZDense"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__getNZDense(CasADi::CRSSparsity* x0)"
// call: "CasADi::getNZDense(x0_)"
extern "C"
    std::vector<int >* CasADi__getNZDense(CasADi::CRSSparsity* x0);
std::vector<int >* CasADi__getNZDense(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new std::vector<int >( CasADi::getNZDense(x0_) );
}


// ================== function "CasADi::reshape''''''" ===============
// cppName: "CasADi::reshape''''''"
// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, int x1, int x2)"
// call: "CasADi::reshape(x0_, x1_, x2_)"
extern "C"
    CasADi::CRSSparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, int x1, int x2);
CasADi::CRSSparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, int x1, int x2){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::CRSSparsity( CasADi::reshape(x0_, x1_, x2_) );
}


// ================== function "CasADi::vec'''" ===============
// cppName: "CasADi::vec'''"
// cWrapperName: "CasADi__vec_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__vec_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__vec_TIC_TIC_TIC(CasADi::CRSSparsity* x0);
CasADi::CRSSparsity* CasADi__vec_TIC_TIC_TIC(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::vec(x0_) );
}


// ================== function "CasADi::trans'''" ===============
// cppName: "CasADi::trans'''"
// cWrapperName: "CasADi__trans_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__trans_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"
// call: "CasADi::trans(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__trans_TIC_TIC_TIC(CasADi::CRSSparsity* x0);
CasADi::CRSSparsity* CasADi__trans_TIC_TIC_TIC(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::trans(x0_) );
}


// ================== function "CasADi::lowerSparsity" ===============
// cppName: "CasADi::lowerSparsity"
// cWrapperName: "CasADi__lowerSparsity"
// protoArgs: "(CasADi::CRSSparsity* x0, bool* x1)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CBool)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__lowerSparsity(CasADi::CRSSparsity* x0, bool* x1)"
// call: "CasADi::lowerSparsity(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__lowerSparsity(CasADi::CRSSparsity* x0, bool* x1);
CasADi::CRSSparsity* CasADi__lowerSparsity(CasADi::CRSSparsity* x0, bool* x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    bool x1_ = Marshaling<bool,bool*>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::lowerSparsity(x0_, x1_) );
}


// ================== function "CasADi::lowerSparsity'" ===============
// cppName: "CasADi::lowerSparsity'"
// cWrapperName: "CasADi__lowerSparsity_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__lowerSparsity_TIC(CasADi::CRSSparsity* x0)"
// call: "CasADi::lowerSparsity(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__lowerSparsity_TIC(CasADi::CRSSparsity* x0);
CasADi::CRSSparsity* CasADi__lowerSparsity_TIC(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::lowerSparsity(x0_) );
}


// ================== function "CasADi::lowerNZ" ===============
// cppName: "CasADi::lowerNZ"
// cWrapperName: "CasADi__lowerNZ"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__lowerNZ(CasADi::CRSSparsity* x0)"
// call: "CasADi::lowerNZ(x0_)"
extern "C"
    std::vector<int >* CasADi__lowerNZ(CasADi::CRSSparsity* x0);
std::vector<int >* CasADi__lowerNZ(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new std::vector<int >( CasADi::lowerNZ(x0_) );
}


// ================== function "CasADi::sp_triplet" ===============
// cppName: "CasADi::sp_triplet"
// cWrapperName: "CasADi__sp_triplet"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5)"
// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt)),Ref (Vec (NonVec CInt)),Val (NonVec CBool)]
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5)"
// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5);
CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* 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,bool*>::marshal(x5);

    return new CasADi::CRSSparsity( CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_, x5_) );
}


// ================== function "CasADi::sp_triplet'" ===============
// cppName: "CasADi::sp_triplet'"
// cWrapperName: "CasADi__sp_triplet_TIC"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4)"
// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt)),Ref (Vec (NonVec CInt))]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4)"
// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4);
CasADi::CRSSparsity* CasADi__sp_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 new CasADi::CRSSparsity( CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_) );
}


// ================== function "CasADi::sp_triplet''" ===============
// cppName: "CasADi::sp_triplet''"
// cWrapperName: "CasADi__sp_triplet_TIC_TIC"
// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"
// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);
CasADi::CRSSparsity* CasADi__sp_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 new CasADi::CRSSparsity( CasADi::sp_triplet(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::mul'''''''''" ===============
// cppName: "CasADi::mul'''''''''"
// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::mul(x0_, x1_)"
extern "C"
    CasADi::CRSSparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1);
CasADi::CRSSparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::CRSSparsity( CasADi::mul(x0_, x1_) );
}


// ================== function "CasADi::vertcat'''" ===============
// cppName: "CasADi::vertcat'''"
// cWrapperName: "CasADi__vertcat_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::CRSSparsity* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0)"
// call: "CasADi::vertcat(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0);
CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0){
    std::vector<CasADi::CRSSparsity > x0_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::horzcat'''" ===============
// cppName: "CasADi::horzcat'''"
// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::CRSSparsity* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0)"
// call: "CasADi::horzcat(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0);
CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0){
    std::vector<CasADi::CRSSparsity > x0_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::blkdiag'''" ===============
// cppName: "CasADi::blkdiag'''"
// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::CRSSparsity* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0)"
// call: "CasADi::blkdiag(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0);
CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0){
    std::vector<CasADi::CRSSparsity > x0_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::sp_compress" ===============
// cppName: "CasADi::sp_compress"
// cWrapperName: "CasADi__sp_compress"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<int >*"
// proto: "std::vector<int >* CasADi__sp_compress(CasADi::CRSSparsity* x0)"
// call: "CasADi::sp_compress(x0_)"
extern "C"
    std::vector<int >* CasADi__sp_compress(CasADi::CRSSparsity* x0);
std::vector<int >* CasADi__sp_compress(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new std::vector<int >( CasADi::sp_compress(x0_) );
}


// ================== function "CasADi::sp_compress'" ===============
// cppName: "CasADi::sp_compress'"
// cWrapperName: "CasADi__sp_compress_TIC"
// protoArgs: "(std::vector<int > * x0)"
// params: [ConstRef (Vec (NonVec CInt))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::CRSSparsity*"
// proto: "CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector<int > * x0)"
// call: "CasADi::sp_compress(x0_)"
extern "C"
    CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector<int > * x0);
CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector<int > * x0){
    std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);

    return new CasADi::CRSSparsity( CasADi::sp_compress(x0_) );
}


// ================== function "CasADi::rank" ===============
// cppName: "CasADi::rank"
// cWrapperName: "CasADi__rank"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__rank(CasADi::CRSSparsity* x0)"
// call: "CasADi::rank(x0_)"
extern "C"
    int CasADi__rank(CasADi::CRSSparsity* x0);
int CasADi__rank(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return CasADi::rank(x0_);
}


// ================== function "CasADi::isSingular" ===============
// cppName: "CasADi::isSingular"
// cWrapperName: "CasADi__isSingular"
// protoArgs: "(CasADi::CRSSparsity* x0)"
// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isSingular(CasADi::CRSSparsity* x0)"
// call: "CasADi::isSingular(x0_)"
extern "C"
    bool* CasADi__isSingular(CasADi::CRSSparsity* x0);
bool* CasADi__isSingular(CasADi::CRSSparsity* x0){
    CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);

    return new bool( CasADi::isSingular(x0_) );
}


// ================== function "CasADi::ssym" ===============
// cppName: "CasADi::ssym"
// cWrapperName: "CasADi__ssym"
// protoArgs: "(std::string* x0, int x1, int x2)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym(std::string* x0, int x1, int x2)"
// call: "CasADi::ssym(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__ssym(std::string* x0, int x1, int x2);
CasADi::Matrix< CasADi::SX >* CasADi__ssym(std::string* x0, int x1, int x2){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_, x1_, x2_) );
}


// ================== function "CasADi::ssym'" ===============
// cppName: "CasADi::ssym'"
// cWrapperName: "CasADi__ssym_TIC"
// protoArgs: "(std::string* x0, int x1)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC(std::string* x0, int x1)"
// call: "CasADi::ssym(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC(std::string* x0, int x1);
CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC(std::string* x0, int x1){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_, x1_) );
}


// ================== function "CasADi::ssym''" ===============
// cppName: "CasADi::ssym''"
// cWrapperName: "CasADi__ssym_TIC_TIC"
// protoArgs: "(std::string* x0)"
// params: [ConstRef (NonVec StdString)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC(std::string* x0)"
// call: "CasADi::ssym(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC(std::string* x0);
CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC(std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_) );
}


// ================== function "CasADi::ssym'''" ===============
// cppName: "CasADi::ssym'''"
// cWrapperName: "CasADi__ssym_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2)"
// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2)"
// call: "CasADi::ssym(x0_, x1_, x2_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::ssym(x0_, x1_, x2_) );
}


// ================== function "CasADi::ssym''''" ===============
// cppName: "CasADi::ssym''''"
// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"
// call: "CasADi::ssym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::ssym(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::ssym'''''" ===============
// cppName: "CasADi::ssym'''''"
// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"
// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"
// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"
// call: "CasADi::ssym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3);
std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::ssym(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::ssym''''''" ===============
// cppName: "CasADi::ssym''''''"
// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"
// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"
// call: "CasADi::ssym(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);
std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);

    return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::ssym(x0_, x1_, x2_, x3_, x4_) );
}


// ================== function "CasADi::ssym'''''''" ===============
// cppName: "CasADi::ssym'''''''"
// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::ssym(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1);
CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_, x1_) );
}


// ================== function "CasADi::ssym''''''''" ===============
// cppName: "CasADi::ssym''''''''"
// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::ssym(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_) );
}


// ================== function "CasADi::expand" ===============
// cppName: "CasADi::expand"
// cWrapperName: "CasADi__expand"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__expand(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::expand(x0_, x1_, x2_)"
extern "C"
    void CasADi__expand(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
void CasADi__expand(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return CasADi::expand(x0_, x1_, x2_);
}


// ================== function "CasADi::simplify" ===============
// cppName: "CasADi::simplify"
// cWrapperName: "CasADi__simplify"
// protoArgs: "(CasADi::SX* x0)"
// params: [Ref (NonVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__simplify(CasADi::SX* x0)"
// call: "CasADi::simplify(x0_)"
extern "C"
    void CasADi__simplify(CasADi::SX* x0);
void CasADi__simplify(CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return CasADi::simplify(x0_);
}


// ================== function "CasADi::pw_const" ===============
// cppName: "CasADi::pw_const"
// cWrapperName: "CasADi__pw_const"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__pw_const(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::pw_const(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__pw_const(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__pw_const(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::pw_const(x0_, x1_, x2_) );
}


// ================== function "CasADi::pw_lin" ===============
// cppName: "CasADi::pw_lin"
// cWrapperName: "CasADi__pw_lin"
// protoArgs: "(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__pw_lin(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::pw_lin(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__pw_lin(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__pw_lin(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::pw_lin(x0_, x1_, x2_) );
}


// ================== function "CasADi::if_else" ===============
// cppName: "CasADi::if_else"
// cWrapperName: "CasADi__if_else"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__if_else(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::if_else(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__if_else(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__if_else(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::if_else(x0_, x1_, x2_) );
}


// ================== function "CasADi::heaviside" ===============
// cppName: "CasADi::heaviside"
// cWrapperName: "CasADi__heaviside"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__heaviside(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::heaviside(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__heaviside(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__heaviside(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::heaviside(x0_) );
}


// ================== function "CasADi::rectangle" ===============
// cppName: "CasADi::rectangle"
// cWrapperName: "CasADi__rectangle"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__rectangle(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::rectangle(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__rectangle(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__rectangle(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::rectangle(x0_) );
}


// ================== function "CasADi::triangle" ===============
// cppName: "CasADi::triangle"
// cWrapperName: "CasADi__triangle"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__triangle(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::triangle(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__triangle(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__triangle(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::triangle(x0_) );
}


// ================== function "CasADi::ramp" ===============
// cppName: "CasADi::ramp"
// cWrapperName: "CasADi__ramp"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ramp(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::ramp(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__ramp(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__ramp(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::ramp(x0_) );
}


// ================== function "CasADi::gauss_quadrature" ===============
// cppName: "CasADi::gauss_quadrature"
// cWrapperName: "CasADi__gauss_quadrature"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5)"
// params: [Val (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5)"
// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5);
CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);
    CasADi::Matrix< CasADi::SX > x5_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x5);

    return new CasADi::Matrix< CasADi::SX >( 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::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4)"
// params: [Val (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4)"
// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4);
CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);

    return new CasADi::Matrix< CasADi::SX >( 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::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"
// params: [Val (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"
// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3);
CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);

    return new CasADi::Matrix< CasADi::SX >( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::simplify'" ===============
// cppName: "CasADi::simplify'"
// cWrapperName: "CasADi__simplify_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::simplify(x0_)"
extern "C"
    void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SX >* x0);
void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::simplify(x0_);
}


// ================== function "CasADi::compress" ===============
// cppName: "CasADi::compress"
// cWrapperName: "CasADi__compress"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// params: [Ref (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__compress(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::compress(x0_, x1_)"
extern "C"
    void CasADi__compress(CasADi::Matrix< CasADi::SX >* x0, int x1);
void CasADi__compress(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return CasADi::compress(x0_, x1_);
}


// ================== function "CasADi::compress'" ===============
// cppName: "CasADi::compress'"
// cWrapperName: "CasADi__compress_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__compress_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::compress(x0_)"
extern "C"
    void CasADi__compress_TIC(CasADi::Matrix< CasADi::SX >* x0);
void CasADi__compress_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::compress(x0_);
}


// ================== function "CasADi::substitute" ===============
// cppName: "CasADi::substitute"
// cWrapperName: "CasADi__substitute"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__substitute(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::substitute(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__substitute(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__substitute(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::substitute'" ===============
// cppName: "CasADi::substitute'"
// cWrapperName: "CasADi__substitute_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),ConstRef (Vec (NonVec (CasadiClass SXMatrix))),ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"
// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__substitute_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2)"
// call: "CasADi::substitute(x0_, x1_, x2_)"
extern "C"
    std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__substitute_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2);
std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__substitute_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);
    std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x1);
    std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x2);

    return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::substitute(x0_, x1_, x2_) );
}


// ================== function "CasADi::substituteInPlace" ===============
// cppName: "CasADi::substituteInPlace"
// cWrapperName: "CasADi__substituteInPlace"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Val (NonVec CBool)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2);
void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    bool x2_ = Marshaling<bool,bool*>::marshal(x2);

    return CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::substituteInPlace'" ===============
// cppName: "CasADi::substituteInPlace'"
// cWrapperName: "CasADi__substituteInPlace_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::substituteInPlace(x0_, x1_)"
extern "C"
    void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return CasADi::substituteInPlace(x0_, x1_);
}


// ================== function "CasADi::substituteInPlace''" ===============
// cppName: "CasADi::substituteInPlace''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (Vec (NonVec (CasadiClass SXMatrix))),Val (NonVec CBool)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3);
void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,bool*>::marshal(x3);

    return CasADi::substituteInPlace(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::substituteInPlace'''" ===============
// cppName: "CasADi::substituteInPlace'''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2);
void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);

    return CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::substituteInPlace''''" ===============
// cppName: "CasADi::substituteInPlace''''"
// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix))),Val (NonVec CBool)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);
    std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x1);
    std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);
    bool x3_ = Marshaling<bool,bool*>::marshal(x3);

    return 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::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"
// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix)))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"
// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"
extern "C"
    void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2){
    std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);
    std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x1);
    std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);

    return CasADi::substituteInPlace(x0_, x1_, x2_);
}


// ================== function "CasADi::evalf" ===============
// cppName: "CasADi::evalf"
// cWrapperName: "CasADi__evalf"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::evalf(x0_)"
extern "C"
    CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< double >( CasADi::evalf(x0_) );
}


// ================== function "CasADi::evalf'" ===============
// cppName: "CasADi::evalf'"
// cWrapperName: "CasADi__evalf_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2)"
// call: "CasADi::evalf(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2);
CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);

    return new CasADi::Matrix< double >( CasADi::evalf(x0_, x1_, x2_) );
}


// ================== function "CasADi::isRegular''''" ===============
// cppName: "CasADi::isRegular''''"
// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SX* x0)"
// params: [ConstRef (NonVec (CasadiClass SX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isRegular_TIC_TIC_TIC_TIC(CasADi::SX* x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    bool* CasADi__isRegular_TIC_TIC_TIC_TIC(CasADi::SX* x0);
bool* CasADi__isRegular_TIC_TIC_TIC_TIC(CasADi::SX* x0){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);

    return new bool( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::isRegular'''''" ===============
// cppName: "CasADi::isRegular'''''"
// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::spy" ===============
// cppName: "CasADi::spy"
// cWrapperName: "CasADi__spy"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__spy(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::spy(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__spy(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__spy(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::spy(x0_) );
}


// ================== function "CasADi::dependsOn" ===============
// cppName: "CasADi::dependsOn"
// cWrapperName: "CasADi__dependsOn"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__dependsOn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::dependsOn(x0_, x1_)"
extern "C"
    bool* CasADi__dependsOn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
bool* CasADi__dependsOn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new bool( CasADi::dependsOn(x0_, x1_) );
}


// ================== function "CasADi::getSymbols" ===============
// cppName: "CasADi::getSymbols"
// cWrapperName: "CasADi__getSymbols"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "std::vector<CasADi::SX >*"
// proto: "std::vector<CasADi::SX >* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::getSymbols(x0_)"
extern "C"
    std::vector<CasADi::SX >* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0);
std::vector<CasADi::SX >* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new std::vector<CasADi::SX >( CasADi::getSymbols(x0_) );
}


// ================== function "CasADi::isSmooth" ===============
// cppName: "CasADi::isSmooth"
// cWrapperName: "CasADi__isSmooth"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isSmooth(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isSmooth(x0_)"
extern "C"
    bool* CasADi__isSmooth(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isSmooth(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isSmooth(x0_) );
}


// ================== function "CasADi::isSymbolic" ===============
// cppName: "CasADi::isSymbolic"
// cWrapperName: "CasADi__isSymbolic"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isSymbolic(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isSymbolic(x0_)"
extern "C"
    bool* CasADi__isSymbolic(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isSymbolic(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isSymbolic(x0_) );
}


// ================== function "CasADi::isSymbolicSparse" ===============
// cppName: "CasADi::isSymbolicSparse"
// cWrapperName: "CasADi__isSymbolicSparse"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isSymbolicSparse(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::isSymbolicSparse(x0_)"
extern "C"
    bool* CasADi__isSymbolicSparse(CasADi::Matrix< CasADi::SX >* x0);
bool* CasADi__isSymbolicSparse(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new bool( CasADi::isSymbolicSparse(x0_) );
}


// ================== function "CasADi::jacobian" ===============
// cppName: "CasADi::jacobian"
// cWrapperName: "CasADi__jacobian"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__jacobian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::jacobian(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__jacobian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__jacobian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::jacobian(x0_, x1_) );
}


// ================== function "CasADi::gradient" ===============
// cppName: "CasADi::gradient"
// cWrapperName: "CasADi__gradient"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gradient(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::gradient(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__gradient(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__gradient(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::gradient(x0_, x1_) );
}


// ================== function "CasADi::tangent" ===============
// cppName: "CasADi::tangent"
// cWrapperName: "CasADi__tangent"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__tangent(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::tangent(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__tangent(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__tangent(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::tangent(x0_, x1_) );
}


// ================== function "CasADi::hessian" ===============
// cppName: "CasADi::hessian"
// cWrapperName: "CasADi__hessian"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__hessian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::hessian(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__hessian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__hessian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::hessian(x0_, x1_) );
}


// ================== function "CasADi::hessian'" ===============
// cppName: "CasADi::hessian'"
// cWrapperName: "CasADi__hessian_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"
// call: "CasADi::hessian(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3);
void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);

    return CasADi::hessian(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::jacobianTimesVector" ===============
// cppName: "CasADi::jacobianTimesVector"
// cWrapperName: "CasADi__jacobianTimesVector"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CBool)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3)"
// call: "CasADi::jacobianTimesVector(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3);
CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    bool x3_ = Marshaling<bool,bool*>::marshal(x3);

    return new CasADi::Matrix< CasADi::SX >( CasADi::jacobianTimesVector(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::jacobianTimesVector'" ===============
// cppName: "CasADi::jacobianTimesVector'"
// cWrapperName: "CasADi__jacobianTimesVector_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::jacobianTimesVector(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::jacobianTimesVector(x0_, x1_, x2_) );
}


// ================== function "CasADi::getValue" ===============
// cppName: "CasADi::getValue"
// cWrapperName: "CasADi__getValue"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "double"
// proto: "double CasADi__getValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::getValue(x0_, x1_, x2_)"
extern "C"
    double CasADi__getValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
double CasADi__getValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return CasADi::getValue(x0_, x1_, x2_);
}


// ================== function "CasADi::getValue'" ===============
// cppName: "CasADi::getValue'"
// cWrapperName: "CasADi__getValue_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "double"
// proto: "double CasADi__getValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::getValue(x0_, x1_)"
extern "C"
    double CasADi__getValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);
double CasADi__getValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return CasADi::getValue(x0_, x1_);
}


// ================== function "CasADi::getValue''" ===============
// cppName: "CasADi::getValue''"
// cWrapperName: "CasADi__getValue_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "double"
// proto: "double CasADi__getValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::getValue(x0_)"
extern "C"
    double CasADi__getValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
double CasADi__getValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::getValue(x0_);
}


// ================== function "CasADi::getIntValue" ===============
// cppName: "CasADi::getIntValue"
// cWrapperName: "CasADi__getIntValue"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "int"
// proto: "int CasADi__getIntValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"
// call: "CasADi::getIntValue(x0_, x1_, x2_)"
extern "C"
    int CasADi__getIntValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);
int CasADi__getIntValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return CasADi::getIntValue(x0_, x1_, x2_);
}


// ================== function "CasADi::getIntValue'" ===============
// cppName: "CasADi::getIntValue'"
// cWrapperName: "CasADi__getIntValue_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "int"
// proto: "int CasADi__getIntValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"
// call: "CasADi::getIntValue(x0_, x1_)"
extern "C"
    int CasADi__getIntValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);
int CasADi__getIntValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return CasADi::getIntValue(x0_, x1_);
}


// ================== function "CasADi::getIntValue''" ===============
// cppName: "CasADi::getIntValue''"
// cWrapperName: "CasADi__getIntValue_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__getIntValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::getIntValue(x0_)"
extern "C"
    int CasADi__getIntValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);
int CasADi__getIntValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::getIntValue(x0_);
}


// ================== function "CasADi::fill" ===============
// cppName: "CasADi::fill"
// cWrapperName: "CasADi__fill"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1)"
// params: [Ref (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "void"
// proto: "void CasADi__fill(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1)"
// call: "CasADi::fill(x0_, x1_)"
extern "C"
    void CasADi__fill(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1);
void CasADi__fill(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);

    return CasADi::fill(x0_, x1_);
}


// ================== function "CasADi::taylor" ===============
// cppName: "CasADi::taylor"
// cWrapperName: "CasADi__taylor"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__taylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"
// call: "CasADi::taylor(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__taylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3);
CasADi::Matrix< CasADi::SX >* CasADi__taylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new CasADi::Matrix< CasADi::SX >( CasADi::taylor(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::taylor'" ===============
// cppName: "CasADi::taylor'"
// cWrapperName: "CasADi__taylor_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::taylor(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::taylor(x0_, x1_, x2_) );
}


// ================== function "CasADi::taylor''" ===============
// cppName: "CasADi::taylor''"
// cWrapperName: "CasADi__taylor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::taylor(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::taylor(x0_, x1_) );
}


// ================== function "CasADi::mtaylor" ===============
// cppName: "CasADi::mtaylor"
// cWrapperName: "CasADi__mtaylor"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mtaylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"
// call: "CasADi::mtaylor(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__mtaylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3);
CasADi::Matrix< CasADi::SX >* CasADi__mtaylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new CasADi::Matrix< CasADi::SX >( CasADi::mtaylor(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::mtaylor'" ===============
// cppName: "CasADi::mtaylor'"
// cWrapperName: "CasADi__mtaylor_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"
// call: "CasADi::mtaylor(x0_, x1_, x2_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);
CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);

    return new CasADi::Matrix< CasADi::SX >( CasADi::mtaylor(x0_, x1_, x2_) );
}


// ================== function "CasADi::mtaylor''" ===============
// cppName: "CasADi::mtaylor''"
// cWrapperName: "CasADi__mtaylor_TIC_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),ConstRef (Vec (NonVec CInt))]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4)"
// call: "CasADi::mtaylor(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4);
CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);
    CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);
    std::vector<int > x4_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x4);

    return new CasADi::Matrix< CasADi::SX >( CasADi::mtaylor(x0_, x1_, x2_, x3_, x4_) );
}


// ================== function "CasADi::countNodes" ===============
// cppName: "CasADi::countNodes"
// cWrapperName: "CasADi__countNodes"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "int"
// proto: "int CasADi__countNodes(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::countNodes(x0_)"
extern "C"
    int CasADi__countNodes(CasADi::Matrix< CasADi::SX >* x0);
int CasADi__countNodes(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::countNodes(x0_);
}


// ================== function "CasADi::getOperatorRepresentation" ===============
// cppName: "CasADi::getOperatorRepresentation"
// cWrapperName: "CasADi__getOperatorRepresentation"
// protoArgs: "(CasADi::SX* x0, std::vector<std::string* > * x1)"
// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (Vec (NonVec StdString))]
// args: "(x0_, x1_)"
// cWrapperRetType: "std::string*"
// proto: "std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector<std::string* > * x1)"
// call: "CasADi::getOperatorRepresentation(x0_, x1_)"
extern "C"
    std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector<std::string* > * x1);
std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector<std::string* > * x1){
    CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);
    std::vector<std::string > x1_ = Marshaling<std::vector<std::string >,std::vector<std::string* > *>::marshal(x1);

    return new std::string( CasADi::getOperatorRepresentation(x0_, x1_) );
}


// ================== function "CasADi::getFree" ===============
// cppName: "CasADi::getFree"
// cWrapperName: "CasADi__getFree"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__getFree(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::getFree(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__getFree(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__getFree(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::getFree(x0_) );
}


// ================== function "CasADi::extractShared" ===============
// cppName: "CasADi::extractShared"
// cWrapperName: "CasADi__extractShared"
// protoArgs: "(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4)"
// params: [Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),ConstRef (NonVec StdString),ConstRef (NonVec StdString)]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4)"
// call: "CasADi::extractShared(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    void CasADi__extractShared(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4);
void CasADi__extractShared(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);
    std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);
    std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

    return CasADi::extractShared(x0_, x1_, x2_, x3_, x4_);
}


// ================== function "CasADi::extractShared'" ===============
// cppName: "CasADi::extractShared'"
// cWrapperName: "CasADi__extractShared_TIC"
// protoArgs: "(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3)"
// params: [Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),ConstRef (NonVec StdString)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3)"
// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)"
extern "C"
    void CasADi__extractShared_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3);
void CasADi__extractShared_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);
    std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);

    return CasADi::extractShared(x0_, x1_, x2_, x3_);
}


// ================== function "CasADi::extractShared''" ===============
// cppName: "CasADi::extractShared''"
// cWrapperName: "CasADi__extractShared_TIC_TIC"
// protoArgs: "(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2)"
// params: [Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX)))]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "void"
// proto: "void CasADi__extractShared_TIC_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2)"
// call: "CasADi::extractShared(x0_, x1_, x2_)"
extern "C"
    void CasADi__extractShared_TIC_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2);
void CasADi__extractShared_TIC_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2){
    std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);
    std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x1);
    std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);

    return CasADi::extractShared(x0_, x1_, x2_);
}


// ================== function "CasADi::printCompact'" ===============
// cppName: "CasADi::printCompact'"
// cWrapperName: "CasADi__printCompact_TIC"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::printCompact(x0_)"
extern "C"
    void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SX >* x0);
void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return CasADi::printCompact(x0_);
}


// ================== function "CasADi::poly_coeff" ===============
// cppName: "CasADi::poly_coeff"
// cWrapperName: "CasADi__poly_coeff"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"
// call: "CasADi::poly_coeff(x0_, x1_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);
CasADi::Matrix< CasADi::SX >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);
    CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);

    return new CasADi::Matrix< CasADi::SX >( CasADi::poly_coeff(x0_, x1_) );
}


// ================== function "CasADi::poly_roots" ===============
// cppName: "CasADi::poly_roots"
// cWrapperName: "CasADi__poly_roots"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__poly_roots(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::poly_roots(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__poly_roots(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__poly_roots(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::poly_roots(x0_) );
}


// ================== function "CasADi::eig_symbolic" ===============
// cppName: "CasADi::eig_symbolic"
// cWrapperName: "CasADi__eig_symbolic"
// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"
// params: [ConstRef (NonVec (CasadiClass SXMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"
// proto: "CasADi::Matrix< CasADi::SX >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SX >* x0)"
// call: "CasADi::eig_symbolic(x0_)"
extern "C"
    CasADi::Matrix< CasADi::SX >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SX >* x0);
CasADi::Matrix< CasADi::SX >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SX >* x0){
    CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);

    return new CasADi::Matrix< CasADi::SX >( CasADi::eig_symbolic(x0_) );
}


// ================== function "CasADi::vertcat''''" ===============
// cppName: "CasADi::vertcat''''"
// cWrapperName: "CasADi__vertcat_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::MX( CasADi::vertcat(x0_) );
}


// ================== function "CasADi::vertsplit'''''''''" ===============
// cppName: "CasADi::vertsplit'''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector<int > * x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec 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(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(CasADi::MX* x0, std::vector<int > * x1);
std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);

    return new std::vector<CasADi::MX >( CasADi::vertsplit(x0_, x1_) );
}


// ================== function "CasADi::vertsplit''''''''''" ===============
// cppName: "CasADi::vertsplit''''''''''"
// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec 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, 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, int x1);
std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<CasADi::MX >( 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)"
// params: [ConstRef (NonVec (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(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(CasADi::MX* x0);
std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new std::vector<CasADi::MX >( CasADi::vertsplit(x0_) );
}


// ================== function "CasADi::horzcat''''" ===============
// cppName: "CasADi::horzcat''''"
// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::MX( CasADi::horzcat(x0_) );
}


// ================== function "CasADi::horzsplit'''''''''" ===============
// cppName: "CasADi::horzsplit'''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector<int > * x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec 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(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(CasADi::MX* x0, std::vector<int > * x1);
std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);

    return new std::vector<CasADi::MX >( CasADi::horzsplit(x0_, x1_) );
}


// ================== function "CasADi::horzsplit''''''''''" ===============
// cppName: "CasADi::horzsplit''''''''''"
// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, int x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec 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, 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, int x1);
std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<CasADi::MX >( 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)"
// params: [ConstRef (NonVec (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(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(CasADi::MX* x0);
std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new std::vector<CasADi::MX >( CasADi::horzsplit(x0_) );
}


// ================== function "CasADi::blockcat'''" ===============
// cppName: "CasADi::blockcat'''"
// cWrapperName: "CasADi__blockcat_TIC_TIC_TIC"
// protoArgs: "(std::vector<std::vector<CasADi::MX* > > * x0)"
// params: [ConstRef (Vec (Vec (NonVec (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 new CasADi::MX( 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 (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);
    std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);

    return new std::vector<std::vector<CasADi::MX > >( 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 (NonVec (CasadiClass MX)),Val (NonVec CInt),Val (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new std::vector<std::vector<CasADi::MX > >( 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 (NonVec (CasadiClass MX)),Val (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new std::vector<std::vector<CasADi::MX > >( 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 (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new std::vector<std::vector<CasADi::MX > >( CasADi::blocksplit(x0_) );
}


// ================== function "CasADi::veccat'''" ===============
// cppName: "CasADi::veccat'''"
// cWrapperName: "CasADi__veccat_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::MX( CasADi::veccat(x0_) );
}


// ================== function "CasADi::flattencat'''" ===============
// cppName: "CasADi::flattencat'''"
// cWrapperName: "CasADi__flattencat_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"
// call: "CasADi::flattencat(x0_)"
extern "C"
    CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);
CasADi::MX* CasADi__flattencat_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 new CasADi::MX( CasADi::flattencat(x0_) );
}


// ================== function "CasADi::vecNZcat'''" ===============
// cppName: "CasADi::vecNZcat'''"
// cWrapperName: "CasADi__vecNZcat_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::MX( CasADi::vecNZcat(x0_) );
}


// ================== function "CasADi::flattenNZcat'''" ===============
// cppName: "CasADi::flattenNZcat'''"
// cWrapperName: "CasADi__flattenNZcat_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"
// call: "CasADi::flattenNZcat(x0_)"
extern "C"
    CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);
CasADi::MX* CasADi__flattenNZcat_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 new CasADi::MX( CasADi::flattenNZcat(x0_) );
}


// ================== function "CasADi::norm_F'''" ===============
// cppName: "CasADi::norm_F'''"
// cWrapperName: "CasADi__norm_F_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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 (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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 (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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 (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::norm_inf(x0_) );
}


// ================== function "CasADi::trans''''" ===============
// cppName: "CasADi::trans''''"
// cWrapperName: "CasADi__trans_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__trans_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::trans(x0_)"
extern "C"
    CasADi::MX* CasADi__trans_TIC_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__trans_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::trans(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::CRSSparsity* x2)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// 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::CRSSparsity* 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::CRSSparsity* x2);
CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::CRSSparsity* x2){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);
    CasADi::CRSSparsity x2_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x2);

    return new CasADi::MX( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( 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 (Vec (NonVec (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 new CasADi::MX( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);
    CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);

    return new CasADi::MX( 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::CRSSparsity* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::reshape(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::CRSSparsity* x1);
CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::CRSSparsity* x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::MX( CasADi::reshape(x0_, x1_) );
}


// ================== function "CasADi::vec''''" ===============
// cppName: "CasADi::vec''''"
// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::vec(x0_) );
}


// ================== function "CasADi::flatten'''" ===============
// cppName: "CasADi::flatten'''"
// cWrapperName: "CasADi__flatten_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__flatten_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::flatten(x0_)"
extern "C"
    CasADi::MX* CasADi__flatten_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__flatten_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::flatten(x0_) );
}


// ================== function "CasADi::vecNZ'''" ===============
// cppName: "CasADi::vecNZ'''"
// cWrapperName: "CasADi__vecNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::vecNZ(x0_) );
}


// ================== function "CasADi::flattenNZ'''" ===============
// cppName: "CasADi::flattenNZ'''"
// cWrapperName: "CasADi__flattenNZ_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__flattenNZ_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::flattenNZ(x0_)"
extern "C"
    CasADi::MX* CasADi__flattenNZ_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__flattenNZ_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::flattenNZ(x0_) );
}


// ================== function "CasADi::unite'''" ===============
// cppName: "CasADi::unite'''"
// cWrapperName: "CasADi__unite_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::unite(x0_, x1_) );
}


// ================== function "CasADi::isSymbolic'" ===============
// cppName: "CasADi::isSymbolic'"
// cWrapperName: "CasADi__isSymbolic_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isSymbolic_TIC(CasADi::MX* x0)"
// call: "CasADi::isSymbolic(x0_)"
extern "C"
    bool* CasADi__isSymbolic_TIC(CasADi::MX* x0);
bool* CasADi__isSymbolic_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isSymbolic(x0_) );
}


// ================== function "CasADi::isSymbolicSparse'" ===============
// cppName: "CasADi::isSymbolicSparse'"
// cWrapperName: "CasADi__isSymbolicSparse_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isSymbolicSparse_TIC(CasADi::MX* x0)"
// call: "CasADi::isSymbolicSparse(x0_)"
extern "C"
    bool* CasADi__isSymbolicSparse_TIC(CasADi::MX* x0);
bool* CasADi__isSymbolicSparse_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isSymbolicSparse(x0_) );
}


// ================== function "CasADi::isIdentity'''" ===============
// cppName: "CasADi::isIdentity'''"
// cWrapperName: "CasADi__isIdentity_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isIdentity_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isIdentity(x0_)"
extern "C"
    bool* CasADi__isIdentity_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isIdentity_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isIdentity(x0_) );
}


// ================== function "CasADi::isZero'''" ===============
// cppName: "CasADi::isZero'''"
// cWrapperName: "CasADi__isZero_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isZero_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isZero(x0_)"
extern "C"
    bool* CasADi__isZero_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isZero_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isZero(x0_) );
}


// ================== function "CasADi::isOne'''" ===============
// cppName: "CasADi::isOne'''"
// cWrapperName: "CasADi__isOne_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isOne_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isOne(x0_)"
extern "C"
    bool* CasADi__isOne_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isOne_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isOne(x0_) );
}


// ================== function "CasADi::simplify''" ===============
// cppName: "CasADi::simplify''"
// cWrapperName: "CasADi__simplify_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [Ref (NonVec (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);

    return CasADi::simplify(x0_);
}


// ================== function "CasADi::isTranspose" ===============
// cppName: "CasADi::isTranspose"
// cWrapperName: "CasADi__isTranspose"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isTranspose(CasADi::MX* x0)"
// call: "CasADi::isTranspose(x0_)"
extern "C"
    bool* CasADi__isTranspose(CasADi::MX* x0);
bool* CasADi__isTranspose(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isTranspose(x0_) );
}


// ================== function "CasADi::isMinusOne'''" ===============
// cppName: "CasADi::isMinusOne'''"
// cWrapperName: "CasADi__isMinusOne_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isMinusOne_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isMinusOne(x0_)"
extern "C"
    bool* CasADi__isMinusOne_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isMinusOne_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isMinusOne(x0_) );
}


// ================== function "CasADi::isVector'''" ===============
// cppName: "CasADi::isVector'''"
// cWrapperName: "CasADi__isVector_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isVector_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isVector(x0_)"
extern "C"
    bool* CasADi__isVector_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isVector_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isVector(x0_) );
}


// ================== function "CasADi::isDense'''" ===============
// cppName: "CasADi::isDense'''"
// cWrapperName: "CasADi__isDense_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isDense_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isDense(x0_)"
extern "C"
    bool* CasADi__isDense_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isDense_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isDense(x0_) );
}


// ================== function "CasADi::isRegular''''''" ===============
// cppName: "CasADi::isRegular''''''"
// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::isRegular(x0_)"
extern "C"
    bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);
bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new bool( CasADi::isRegular(x0_) );
}


// ================== function "CasADi::trace'''" ===============
// cppName: "CasADi::trace'''"
// cWrapperName: "CasADi__trace_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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 (NonVec (CasadiClass MX)),Val (NonVec CInt),Val (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::MX( CasADi::repmat(x0_, x1_, x2_) );
}


// ================== function "CasADi::makeDense'''" ===============
// cppName: "CasADi::makeDense'''"
// cWrapperName: "CasADi__makeDense_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [Ref (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "void"
// proto: "void CasADi__makeDense_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::makeDense(x0_)"
extern "C"
    void CasADi__makeDense_TIC_TIC_TIC(CasADi::MX* x0);
void CasADi__makeDense_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return CasADi::makeDense(x0_);
}


// ================== function "CasADi::densify'''" ===============
// cppName: "CasADi::densify'''"
// cWrapperName: "CasADi__densify_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__densify_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::densify(x0_)"
extern "C"
    CasADi::MX* CasADi__densify_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__densify_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::densify(x0_) );
}


// ================== function "CasADi::full'''" ===============
// cppName: "CasADi::full'''"
// cWrapperName: "CasADi__full_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__full_TIC_TIC_TIC(CasADi::MX* x0)"
// call: "CasADi::full(x0_)"
extern "C"
    CasADi::MX* CasADi__full_TIC_TIC_TIC(CasADi::MX* x0);
CasADi::MX* CasADi__full_TIC_TIC_TIC(CasADi::MX* x0){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::full(x0_) );
}


// ================== function "CasADi::createParent" ===============
// cppName: "CasADi::createParent"
// cWrapperName: "CasADi__createParent"
// protoArgs: "(std::vector<CasADi::MX* >* x0)"
// params: [Ref (Vec (NonVec (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 new CasADi::MX( CasADi::createParent(x0_) );
}


// ================== function "CasADi::countNodes'" ===============
// cppName: "CasADi::countNodes'"
// cWrapperName: "CasADi__countNodes_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return CasADi::countNodes(x0_);
}


// ================== function "CasADi::diag'''" ===============
// cppName: "CasADi::diag'''"
// cWrapperName: "CasADi__diag_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::diag(x0_) );
}


// ================== function "CasADi::blkdiag''''" ===============
// cppName: "CasADi::blkdiag''''"
// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new CasADi::MX( CasADi::blkdiag(x0_) );
}


// ================== function "CasADi::sumRows'''" ===============
// cppName: "CasADi::sumRows'''"
// cWrapperName: "CasADi__sumRows_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::sumRows(x0_) );
}


// ================== function "CasADi::sumCols'''" ===============
// cppName: "CasADi::sumCols'''"
// cWrapperName: "CasADi__sumCols_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::sumCols(x0_) );
}


// ================== function "CasADi::sumAll'''" ===============
// cppName: "CasADi::sumAll'''"
// cWrapperName: "CasADi__sumAll_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::sumAll(x0_) );
}


// ================== function "CasADi::polyval'''" ===============
// cppName: "CasADi::polyval'''"
// cWrapperName: "CasADi__polyval_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::polyval(x0_, x1_) );
}


// ================== function "CasADi::msym" ===============
// cppName: "CasADi::msym"
// cWrapperName: "CasADi__msym"
// protoArgs: "(std::string* x0, int x1, int x2)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__msym(std::string* x0, int x1, int x2)"
// call: "CasADi::msym(x0_, x1_, x2_)"
extern "C"
    CasADi::MX* CasADi__msym(std::string* x0, int x1, int x2);
CasADi::MX* CasADi__msym(std::string* x0, int x1, int x2){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::MX( CasADi::msym(x0_, x1_, x2_) );
}


// ================== function "CasADi::msym'" ===============
// cppName: "CasADi::msym'"
// cWrapperName: "CasADi__msym_TIC"
// protoArgs: "(std::string* x0, int x1)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt)]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__msym_TIC(std::string* x0, int x1)"
// call: "CasADi::msym(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__msym_TIC(std::string* x0, int x1);
CasADi::MX* CasADi__msym_TIC(std::string* x0, int x1){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);

    return new CasADi::MX( CasADi::msym(x0_, x1_) );
}


// ================== function "CasADi::msym''" ===============
// cppName: "CasADi::msym''"
// cWrapperName: "CasADi__msym_TIC_TIC"
// protoArgs: "(std::string* x0)"
// params: [ConstRef (NonVec StdString)]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__msym_TIC_TIC(std::string* x0)"
// call: "CasADi::msym(x0_)"
extern "C"
    CasADi::MX* CasADi__msym_TIC_TIC(std::string* x0);
CasADi::MX* CasADi__msym_TIC_TIC(std::string* x0){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    return new CasADi::MX( CasADi::msym(x0_) );
}


// ================== function "CasADi::msym'''" ===============
// cppName: "CasADi::msym'''"
// cWrapperName: "CasADi__msym_TIC_TIC_TIC"
// protoArgs: "(CasADi::Matrix< double >* x0)"
// params: [ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__msym_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"
// call: "CasADi::msym(x0_)"
extern "C"
    CasADi::MX* CasADi__msym_TIC_TIC_TIC(CasADi::Matrix< double >* x0);
CasADi::MX* CasADi__msym_TIC_TIC_TIC(CasADi::Matrix< double >* x0){
    CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);

    return new CasADi::MX( CasADi::msym(x0_) );
}


// ================== function "CasADi::msym''''" ===============
// cppName: "CasADi::msym''''"
// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1)"
// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::MX*"
// proto: "CasADi::MX* CasADi__msym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1)"
// call: "CasADi::msym(x0_, x1_)"
extern "C"
    CasADi::MX* CasADi__msym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1);
CasADi::MX* CasADi__msym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);

    return new CasADi::MX( CasADi::msym(x0_, x1_) );
}


// ================== function "CasADi::msym'''''" ===============
// cppName: "CasADi::msym'''''"
// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2)"
// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "std::vector<CasADi::MX >*"
// proto: "std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2)"
// call: "CasADi::msym(x0_, x1_, x2_)"
extern "C"
    std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2);
std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new std::vector<CasADi::MX >( CasADi::msym(x0_, x1_, x2_) );
}


// ================== function "CasADi::msym''''''" ===============
// cppName: "CasADi::msym''''''"
// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector<CasADi::MX >*"
// proto: "std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"
// call: "CasADi::msym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);
std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new std::vector<CasADi::MX >( CasADi::msym(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::msym'''''''" ===============
// cppName: "CasADi::msym'''''''"
// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"
// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"
// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"
// call: "CasADi::msym(x0_, x1_, x2_, x3_)"
extern "C"
    std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3);
std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new std::vector<std::vector<CasADi::MX > >( CasADi::msym(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::msym''''''''" ===============
// cppName: "CasADi::msym''''''''"
// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"
// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_, x4_)"
// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"
// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"
// call: "CasADi::msym(x0_, x1_, x2_, x3_, x4_)"
extern "C"
    std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_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__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){
    std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
    int x1_ = Marshaling<int,int>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);
    int x4_ = Marshaling<int,int>::marshal(x4);

    return new std::vector<std::vector<CasADi::MX > >( CasADi::msym(x0_, x1_, x2_, x3_, x4_) );
}


// ================== function "CasADi::isEqual'''" ===============
// cppName: "CasADi::isEqual'''"
// cWrapperName: "CasADi__isEqual_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "bool*"
// proto: "bool* CasADi__isEqual_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"
// call: "CasADi::isEqual(x0_, x1_)"
extern "C"
    bool* CasADi__isEqual_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);
bool* CasADi__isEqual_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){
    CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new bool( CasADi::isEqual(x0_, x1_) );
}


// ================== function "CasADi::getOperatorRepresentation'" ===============
// cppName: "CasADi::getOperatorRepresentation'"
// cWrapperName: "CasADi__getOperatorRepresentation_TIC"
// protoArgs: "(CasADi::MX* x0, std::vector<std::string* > * x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec 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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::vector<std::string > x1_ = Marshaling<std::vector<std::string >,std::vector<std::string* > *>::marshal(x1);

    return new std::string( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);
    CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);

    return new CasADi::MX( 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 (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (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 new std::vector<CasADi::MX >( 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 (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);
    std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x2);

    return new CasADi::MX( 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 (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (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 new std::vector<CasADi::MX >( 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, bool* x2)"
// params: [ConstRef (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Val (NonVec 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, bool* 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, bool* x2);
void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, bool* 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,bool*>::marshal(x2);

    return 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 (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (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);

    return 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, bool* x3)"
// params: [ConstRef (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Val (NonVec 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, bool* 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, bool* 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, bool* 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,bool*>::marshal(x3);

    return 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 (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (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);

    return 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 (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),ConstRef (NonVec StdString),ConstRef (NonVec 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 x3_ = Marshaling<std::string,std::string*>::marshal(x3);
    std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);

    return 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 (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),ConstRef (NonVec 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 x3_ = Marshaling<std::string,std::string*>::marshal(x3);

    return 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 (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (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);

    return CasADi::extractShared(x0_, x1_, x2_);
}


// ================== function "CasADi::printCompact'''" ===============
// cppName: "CasADi::printCompact'''"
// cWrapperName: "CasADi__printCompact_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return CasADi::printCompact(x0_);
}


// ================== function "CasADi::jacobian'" ===============
// cppName: "CasADi::jacobian'"
// cWrapperName: "CasADi__jacobian_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::jacobian(x0_, x1_) );
}


// ================== function "CasADi::gradient'" ===============
// cppName: "CasADi::gradient'"
// cWrapperName: "CasADi__gradient_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::gradient(x0_, x1_) );
}


// ================== function "CasADi::tangent'" ===============
// cppName: "CasADi::tangent'"
// cWrapperName: "CasADi__tangent_TIC"
// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::tangent(x0_, x1_) );
}


// ================== function "CasADi::nullspace'''" ===============
// cppName: "CasADi::nullspace'''"
// cWrapperName: "CasADi__nullspace_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::nullspace(x0_) );
}


// ================== function "CasADi::det'''" ===============
// cppName: "CasADi::det'''"
// cWrapperName: "CasADi__det_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::det(x0_) );
}


// ================== function "CasADi::inv'''" ===============
// cppName: "CasADi::inv'''"
// cWrapperName: "CasADi__inv_TIC_TIC_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( CasADi::inv(x0_) );
}


// ================== function "CasADi::getSymbols'" ===============
// cppName: "CasADi::getSymbols'"
// cWrapperName: "CasADi__getSymbols_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new std::vector<CasADi::MX >( CasADi::getSymbols(x0_) );
}


// ================== function "CasADi::getSymbols''" ===============
// cppName: "CasADi::getSymbols''"
// cWrapperName: "CasADi__getSymbols_TIC_TIC"
// protoArgs: "(std::vector<CasADi::MX* > * x0)"
// params: [ConstRef (Vec (NonVec (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 new std::vector<CasADi::MX >( CasADi::getSymbols(x0_) );
}


// ================== function "CasADi::matrix_expand" ===============
// cppName: "CasADi::matrix_expand"
// cWrapperName: "CasADi__matrix_expand"
// protoArgs: "(CasADi::MX* x0, std::vector<CasADi::MX* > * x1)"
// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);

    return new CasADi::MX( CasADi::matrix_expand(x0_, x1_) );
}


// ================== function "CasADi::matrix_expand'" ===============
// cppName: "CasADi::matrix_expand'"
// cWrapperName: "CasADi__matrix_expand_TIC"
// protoArgs: "(CasADi::MX* x0)"
// params: [ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);

    return new CasADi::MX( 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 (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (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 new std::vector<CasADi::MX >( 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 (Vec (NonVec (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 new std::vector<CasADi::MX >( 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 (NonVec (CasadiClass MX)),ConstRef (NonVec (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 x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::MX( CasADi::kron(x0_, x1_) );
}


// ================== function "CasADi::parameterizeTime" ===============
// cppName: "CasADi::parameterizeTime"
// cWrapperName: "CasADi__parameterizeTime"
// protoArgs: "(CasADi::FX* x0)"
// params: [Val (NonVec (CasadiClass FX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__parameterizeTime(CasADi::FX* x0)"
// call: "CasADi::parameterizeTime(x0_)"
extern "C"
    CasADi::FX* CasADi__parameterizeTime(CasADi::FX* x0);
CasADi::FX* CasADi__parameterizeTime(CasADi::FX* x0){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);

    return new CasADi::FX( CasADi::parameterizeTime(x0_) );
}


// ================== function "CasADi::parameterizeTimeOutput" ===============
// cppName: "CasADi::parameterizeTimeOutput"
// cWrapperName: "CasADi__parameterizeTimeOutput"
// protoArgs: "(CasADi::FX* x0)"
// params: [Val (NonVec (CasadiClass FX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__parameterizeTimeOutput(CasADi::FX* x0)"
// call: "CasADi::parameterizeTimeOutput(x0_)"
extern "C"
    CasADi::FX* CasADi__parameterizeTimeOutput(CasADi::FX* x0);
CasADi::FX* CasADi__parameterizeTimeOutput(CasADi::FX* x0){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);

    return new CasADi::FX( CasADi::parameterizeTimeOutput(x0_) );
}


// ================== function "CasADi::numSample1D" ===============
// cppName: "CasADi::numSample1D"
// cWrapperName: "CasADi__numSample1D"
// protoArgs: "(CasADi::FX* x0, CasADi::Matrix< double >* x1)"
// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__numSample1D(CasADi::FX* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::numSample1D(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__numSample1D(CasADi::FX* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__numSample1D(CasADi::FX* x0, CasADi::Matrix< double >* x1){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::numSample1D(x0_, x1_) );
}


// ================== function "CasADi::numSample1DT" ===============
// cppName: "CasADi::numSample1DT"
// cWrapperName: "CasADi__numSample1DT"
// protoArgs: "(CasADi::FX* x0, CasADi::Matrix< double >* x1)"
// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__numSample1DT(CasADi::FX* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::numSample1DT(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__numSample1DT(CasADi::FX* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__numSample1DT(CasADi::FX* x0, CasADi::Matrix< double >* x1){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::numSample1DT(x0_, x1_) );
}


// ================== function "CasADi::numSample2D" ===============
// cppName: "CasADi::numSample2D"
// cWrapperName: "CasADi__numSample2D"
// protoArgs: "(CasADi::FX* x0, CasADi::Matrix< double >* x1)"
// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass DMatrix))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::Matrix< double >*"
// proto: "CasADi::Matrix< double >* CasADi__numSample2D(CasADi::FX* x0, CasADi::Matrix< double >* x1)"
// call: "CasADi::numSample2D(x0_, x1_)"
extern "C"
    CasADi::Matrix< double >* CasADi__numSample2D(CasADi::FX* x0, CasADi::Matrix< double >* x1);
CasADi::Matrix< double >* CasADi__numSample2D(CasADi::FX* x0, CasADi::Matrix< double >* x1){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);
    CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);

    return new CasADi::Matrix< double >( CasADi::numSample2D(x0_, x1_) );
}


// ================== function "CasADi::vec'''''" ===============
// cppName: "CasADi::vec'''''"
// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::SXFunction* x0)"
// params: [ConstRef (NonVec (CasadiClass SXFunction))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::SXFunction*"
// proto: "CasADi::SXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::SXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* x0);
CasADi::SXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* x0){
    CasADi::SXFunction x0_ = Marshaling<CasADi::SXFunction,CasADi::SXFunction*>::marshal(x0);

    return new CasADi::SXFunction( CasADi::vec(x0_) );
}


// ================== function "CasADi::vec''''''" ===============
// cppName: "CasADi::vec''''''"
// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC"
// protoArgs: "(CasADi::FX* x0)"
// params: [ConstRef (NonVec (CasadiClass FX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::MXFunction*"
// proto: "CasADi::MXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::FX* x0)"
// call: "CasADi::vec(x0_)"
extern "C"
    CasADi::MXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::FX* x0);
CasADi::MXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::FX* x0){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);

    return new CasADi::MXFunction( CasADi::vec(x0_) );
}


// ================== function "CasADi::collocationPoints" ===============
// cppName: "CasADi::collocationPoints"
// cWrapperName: "CasADi__collocationPoints"
// protoArgs: "(int x0, std::string* x1)"
// params: [Val (NonVec CInt),ConstRef (NonVec 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 x1_ = Marshaling<std::string,std::string*>::marshal(x1);

    return new std::vector<double >( CasADi::collocationPoints(x0_, x1_) );
}


// ================== function "CasADi::collocationPoints'" ===============
// cppName: "CasADi::collocationPoints'"
// cWrapperName: "CasADi__collocationPoints_TIC"
// protoArgs: "(int x0)"
// params: [Val (NonVec 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 new std::vector<double >( 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 (Vec (NonVec CDouble)),Ref (Vec (Vec (NonVec CDouble))),Ref (Vec (NonVec 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);

    return CasADi::collocationInterpolators(x0_, x1_, x2_);
}


// ================== function "CasADi::explicitRK" ===============
// cppName: "CasADi::explicitRK"
// cWrapperName: "CasADi__explicitRK"
// protoArgs: "(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3)"
// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_, x3_)"
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__explicitRK(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3)"
// call: "CasADi::explicitRK(x0_, x1_, x2_, x3_)"
extern "C"
    CasADi::FX* CasADi__explicitRK(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3);
CasADi::FX* CasADi__explicitRK(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);
    int x3_ = Marshaling<int,int>::marshal(x3);

    return new CasADi::FX( CasADi::explicitRK(x0_, x1_, x2_, x3_) );
}


// ================== function "CasADi::explicitRK'" ===============
// cppName: "CasADi::explicitRK'"
// cWrapperName: "CasADi__explicitRK_TIC"
// protoArgs: "(CasADi::FX* x0, CasADi::MX* x1, int x2)"
// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt)]
// args: "(x0_, x1_, x2_)"
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__explicitRK_TIC(CasADi::FX* x0, CasADi::MX* x1, int x2)"
// call: "CasADi::explicitRK(x0_, x1_, x2_)"
extern "C"
    CasADi::FX* CasADi__explicitRK_TIC(CasADi::FX* x0, CasADi::MX* x1, int x2);
CasADi::FX* CasADi__explicitRK_TIC(CasADi::FX* x0, CasADi::MX* x1, int x2){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);
    int x2_ = Marshaling<int,int>::marshal(x2);

    return new CasADi::FX( CasADi::explicitRK(x0_, x1_, x2_) );
}


// ================== function "CasADi::explicitRK''" ===============
// cppName: "CasADi::explicitRK''"
// cWrapperName: "CasADi__explicitRK_TIC_TIC"
// protoArgs: "(CasADi::FX* x0, CasADi::MX* x1)"
// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass MX))]
// args: "(x0_, x1_)"
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__explicitRK_TIC_TIC(CasADi::FX* x0, CasADi::MX* x1)"
// call: "CasADi::explicitRK(x0_, x1_)"
extern "C"
    CasADi::FX* CasADi__explicitRK_TIC_TIC(CasADi::FX* x0, CasADi::MX* x1);
CasADi::FX* CasADi__explicitRK_TIC_TIC(CasADi::FX* x0, CasADi::MX* x1){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);
    CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);

    return new CasADi::FX( CasADi::explicitRK(x0_, x1_) );
}


// ================== function "CasADi::explicitRK'''" ===============
// cppName: "CasADi::explicitRK'''"
// cWrapperName: "CasADi__explicitRK_TIC_TIC_TIC"
// protoArgs: "(CasADi::FX* x0)"
// params: [Ref (NonVec (CasadiClass FX))]
// args: "(x0_)"
// cWrapperRetType: "CasADi::FX*"
// proto: "CasADi::FX* CasADi__explicitRK_TIC_TIC_TIC(CasADi::FX* x0)"
// call: "CasADi::explicitRK(x0_)"
extern "C"
    CasADi::FX* CasADi__explicitRK_TIC_TIC_TIC(CasADi::FX* x0);
CasADi::FX* CasADi__explicitRK_TIC_TIC_TIC(CasADi::FX* x0){
    CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);

    return new CasADi::FX( CasADi::explicitRK(x0_) );
}


// ================== delete CInt===============
// classType: CInt
extern "C"
    void delete_std__vector_int_(std::vector<int >* obj);
void delete_std__vector_int_(std::vector<int >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_int__(std::vector<std::vector<int > >* obj);
void delete_std__vector_std__vector_int__(std::vector<std::vector<int > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_int___(std::vector<std::vector<std::vector<int > > >* obj);
void delete_std__vector_std__vector_std__vector_int___(std::vector<std::vector<std::vector<int > > >* obj){
    delete obj;
}

// ================== delete CDouble===============
// classType: CDouble
extern "C"
    void delete_std__vector_double_(std::vector<double >* obj);
void delete_std__vector_double_(std::vector<double >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_double__(std::vector<std::vector<double > >* obj);
void delete_std__vector_std__vector_double__(std::vector<std::vector<double > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_double___(std::vector<std::vector<std::vector<double > > >* obj);
void delete_std__vector_std__vector_std__vector_double___(std::vector<std::vector<std::vector<double > > >* obj){
    delete obj;
}

// ================== delete StdString===============
// classType: StdString
extern "C"
    void delete_std__string(std::string* obj);
void delete_std__string(std::string* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__string_(std::vector<std::string* >* obj);
void delete_std__vector_std__string_(std::vector<std::string* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__string__(std::vector<std::vector<std::string* > >* obj);
void delete_std__vector_std__vector_std__string__(std::vector<std::vector<std::string* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_std__string___(std::vector<std::vector<std::vector<std::string* > > >* obj);
void delete_std__vector_std__vector_std__vector_std__string___(std::vector<std::vector<std::vector<std::string* > > >* obj){
    delete obj;
}

// ================== delete CBool===============
// classType: CBool
extern "C"
    void delete_bool(bool* obj);
void delete_bool(bool* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_bool_(std::vector<bool* >* obj);
void delete_std__vector_bool_(std::vector<bool* >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_bool__(std::vector<std::vector<bool* > >* obj);
void delete_std__vector_std__vector_bool__(std::vector<std::vector<bool* > >* obj){
    delete obj;
}
extern "C"
    void delete_std__vector_std__vector_std__vector_bool___(std::vector<std::vector<std::vector<bool* > > >* obj);
void delete_std__vector_std__vector_std__vector_bool___(std::vector<std::vector<std::vector<bool* > > >* obj){
    delete obj;
}