/* This file was generated by PyBindGen 0.15.0 */
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>


#if PY_VERSION_HEX < 0x020400F0

#define PyEval_ThreadsInitialized() 1

#define Py_CLEAR(op)				\
        do {                            	\
                if (op) {			\
                        PyObject *tmp = (PyObject *)(op);	\
                        (op) = NULL;		\
                        Py_DECREF(tmp);		\
                }				\
        } while (0)


#define Py_VISIT(op)							\
        do { 								\
                if (op) {						\
                        int vret = visit((PyObject *)(op), arg);	\
                        if (vret)					\
                                return vret;				\
                }							\
        } while (0)

#endif



#if PY_VERSION_HEX < 0x020500F0

typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intobjargproc ssizeobjargproc;

#endif


#if     __GNUC__ > 2
# define PYBINDGEN_UNUSED(param) param __attribute__((__unused__))
#elif     __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
# define PYBINDGEN_UNUSED(param) __attribute__((__unused__)) param
#else
# define PYBINDGEN_UNUSED(param) param
#endif  /* !__GNUC__ */

typedef enum _PyBindGenWrapperFlags {
   PYBINDGEN_WRAPPER_FLAG_NONE = 0,
   PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED = (1<<0),
} PyBindGenWrapperFlags;



#include <string>
#include <stdint.h>


class Foo
{
    std::string m_datum;
public:
    Foo () : m_datum ("")
        {}
    Foo (std::string datum) : m_datum (datum)
        {}
    std::string get_datum () const { return m_datum; }

    Foo (Foo const & other) : m_datum (other.get_datum ())
        {}
};

typedef struct {
    PyObject_HEAD
    Foo *obj;
    PyBindGenWrapperFlags flags:8;
} PyFoo;
    

extern PyTypeObject PyFoo_Type;

static PyObject *
_test_wrapper_number_1()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyObject *retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    Py_INCREF((PyObject*) retval);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static PyObject *
_test_wrapper_number_2()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyObject *retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static short unsigned int
_test_wrapper_number_3()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    short unsigned int retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static int
_test_wrapper_number_4()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    int retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return INT_MIN;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return INT_MIN;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static int32_t
_test_wrapper_number_5()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    int32_t retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return INT_MIN;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return INT_MIN;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static float
_test_wrapper_number_6()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    float retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "f", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static long unsigned int
_test_wrapper_number_7()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    long unsigned int retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "k", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static char
_test_wrapper_number_8()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    char retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return '\0';
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "c", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return '\0';
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static int16_t
_test_wrapper_number_9()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    int16_t retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 32767 || tmp < -32768) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static int64_t
_test_wrapper_number_10()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    int64_t retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "L", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static size_t
_test_wrapper_number_11()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    size_t retval;
    unsigned PY_LONG_LONG retval_tmp = retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "K", &retval_tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = retval_tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static unsigned short int
_test_wrapper_number_12()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    unsigned short int retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static Foo
_test_wrapper_number_13()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyFoo *tmp_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return Foo();
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O!", &PyFoo_Type, &tmp_Foo)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return Foo();
    }
    Foo retval = *tmp_Foo->obj;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static short int
_test_wrapper_number_14()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    short int retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 32767 || tmp < -32768) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static uint8_t
_test_wrapper_number_15()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    uint8_t retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static unsigned short
_test_wrapper_number_16()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    unsigned short retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static bool
_test_wrapper_number_17()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    bool retval;
    PyObject *py_boolretval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return false;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &py_boolretval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return false;
    }
    retval = PyObject_IsTrue(py_boolretval);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static long long
_test_wrapper_number_18()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    long long retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "L", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static std::string
_test_wrapper_number_19()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    std::string retval;
    const char *retval_ptr;
    Py_ssize_t retval_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return std::string();
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "s#", &retval_ptr, &retval_len)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return std::string();
    }
    retval = std::string(retval_ptr, retval_len);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static void
_test_wrapper_number_20()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static unsigned long
_test_wrapper_number_21()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    unsigned long retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "k", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static unsigned int
_test_wrapper_number_22()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    unsigned int retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static long long unsigned int
_test_wrapper_number_23()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    long long unsigned int retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "K", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static short
_test_wrapper_number_24()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    short retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 32767 || tmp < -32768) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static Foo *
_test_wrapper_number_25()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    Foo *retval;
    PyFoo *tmp_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O!", &PyFoo_Type, &tmp_Foo)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    retval = new Foo(*tmp_Foo->obj);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static Foo *
_test_wrapper_number_26()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    Foo *retval;
    PyFoo *tmp_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O!", &PyFoo_Type, &tmp_Foo)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    // dangerous!
    retval = tmp_Foo->obj;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static double
_test_wrapper_number_27()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    double retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "d", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static uint32_t
_test_wrapper_number_28()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    uint32_t retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static unsigned long long
_test_wrapper_number_29()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    unsigned long long retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "K", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static char *
_test_wrapper_number_30()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    char *retval;
    char *retval_ptr;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "s", &retval_ptr)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return NULL;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static uint64_t
_test_wrapper_number_31()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    uint64_t retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "K", &retval)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static uint16_t
_test_wrapper_number_32()
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    uint16_t retval;
    int tmp;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", &tmp)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    if (tmp > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return 0;
    }
    retval = tmp;
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return retval;
}

static void
_test_wrapper_number_33(PyObject *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_34(int param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_35(int32_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_36(int64_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "L", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_37(char param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "c", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_38(long long & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "L", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_39(int16_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_40(short & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "h", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_41(short & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "h", param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "h", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_42(short & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "h", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_43(size_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "K", ((unsigned PY_LONG_LONG) param));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_44(unsigned short int param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_45(Foo param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyFoo *py_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = new Foo(param);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", py_Foo);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_46(unsigned long long & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "K", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_47(int & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_48(int & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_49(int & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_50(Foo & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyFoo *py_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = new Foo(param);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", py_Foo);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_51(Foo & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyFoo *py_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = &(param_out);
    py_retval = PyObject_CallFunction(NULL, (char *) "O", py_Foo);
    if (py_retval == NULL) {
        Py_DECREF(py_Foo);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        Py_DECREF(py_Foo);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_Foo->obj = NULL;
    Py_DECREF(py_retval);
    Py_DECREF(py_Foo);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_52(Foo & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyFoo *py_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = &(param_inout);
    py_retval = PyObject_CallFunction(NULL, (char *) "O", py_Foo);
    if (py_retval == NULL) {
        Py_DECREF(py_Foo);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        Py_DECREF(py_Foo);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_Foo->obj = NULL;
    Py_DECREF(py_retval);
    Py_DECREF(py_Foo);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_53(short int param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_54(uint8_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_55(unsigned long & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "k", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_56(std::string param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_ptr;
    Py_ssize_t param_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    param_ptr = (param).c_str();
    param_len = (param).size();
    py_retval = PyObject_CallFunction(NULL, (char *) "s#", param_ptr, param_len);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_57(int *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_58(int *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_59(int *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "i", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_60(uint32_t *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "I", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_61(uint32_t *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_62(uint32_t *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "I", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_63(bool & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyBool_FromLong(param));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_64(bool & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyObject *py_param_out;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &py_param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    param_out = PyObject_IsTrue(py_param_out);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_65(bool & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyObject *py_param_inout;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyBool_FromLong(param_inout));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &py_param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    param_inout = PyObject_IsTrue(py_param_inout);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_66(unsigned short param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_67(float *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "f", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_68(float *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "f", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_69(float *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "f", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "f", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_70(bool param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyBool_FromLong(param));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_71(long long param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "L", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_72(Foo *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyFoo *py_Foo;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = param;
    py_retval = PyObject_CallFunction(NULL, (char *) "N", py_Foo);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_73(int64_t & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "L", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_74(bool *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyBool_FromLong(*param));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_75(bool *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyObject *py_param_out;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &py_param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    *param_out = PyObject_IsTrue(py_param_out);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_76(bool *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    PyObject *py_param_inout;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyBool_FromLong(*param_inout));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "O", &py_param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    *param_inout = PyObject_IsTrue(py_param_inout);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_77(float & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "f", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_78(float & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "f", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_79(float & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "f", param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "f", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_80(float param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "f", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_81(uint64_t & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "K", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_82(int8_t *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "b", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_83(int8_t *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "b", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_84(int8_t *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "b", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "b", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_85(double & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "d", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_86(double & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "d", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_87(double & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "d", param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "d", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_88(unsigned long param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "k", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_89(short int & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "h", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_90(short int & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "h", param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "h", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_91(short int & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "h", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_92(unsigned int param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyLong_FromUnsignedLong(param));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_93(double *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "d", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_94(double *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "d", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_95(double *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "d", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "d", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_96(short param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_97(int16_t & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "h", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_98(int16_t & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "h", param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "h", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_99(int16_t & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "h", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_100(unsigned int *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "I", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_101(unsigned int *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_102(unsigned int *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "I", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "I", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_103(std::string & param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_ptr;
    Py_ssize_t param_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    param_ptr = (param).c_str();
    param_len = (param).size();
    py_retval = PyObject_CallFunction(NULL, (char *) "s#", param_ptr, param_len);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_104(std::string & param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_out_ptr;
    Py_ssize_t param_out_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "s#", &param_out_ptr, &param_out_len)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    param_out = std::string(param_out_ptr, param_out_len);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_105(std::string & param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_inout_ptr;
    Py_ssize_t param_inout_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    param_inout_ptr = (param_inout).c_str();
    param_inout_len = (param_inout).size();
    py_retval = PyObject_CallFunction(NULL, (char *) "s#", param_inout_ptr, param_inout_len);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "s#", &param_inout_ptr, &param_inout_len)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    param_inout = std::string(param_inout_ptr, param_inout_len);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_106(double param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "d", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_107(uint8_t *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "B", *param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_108(uint8_t *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "B", param_out)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_109(uint8_t *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "B", *param_inout);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "B", param_inout)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_110(std::string *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_ptr;
    Py_ssize_t param_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    param_ptr = param->c_str();
    param_len = param->size();
    py_retval = PyObject_CallFunction(NULL, (char *) "s#", param_ptr, param_len);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_111(std::string *param_out)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_out_ptr;
    Py_ssize_t param_out_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "");
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "s#", &param_out_ptr, &param_out_len)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    *param_out = std::string(param_out_ptr, param_out_len);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_112(std::string *param_inout)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    const char *param_inout_ptr;
    Py_ssize_t param_inout_len;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    param_inout_ptr = param_inout->c_str();
    param_inout_len = param_inout->size();
    py_retval = PyObject_CallFunction(NULL, (char *) "s#", param_inout_ptr, param_inout_len);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    py_retval = Py_BuildValue((char*) "(N)", py_retval);
    if (!PyArg_ParseTuple(py_retval, (char *) "s#", &param_inout_ptr, &param_inout_len)) {
        PyErr_Print();
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    *param_inout = std::string(param_inout_ptr, param_inout_len);
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_113(uint32_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "N", PyLong_FromUnsignedLong(param));
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_114(unsigned long long param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "K", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_115(char *param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "s", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_116(uint64_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "K", param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

static void
_test_wrapper_number_117(uint16_t param)
{
    PyGILState_STATE __py_gil_state;
    PyObject *py_retval;
    
    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
    py_retval = PyObject_CallFunction(NULL, (char *) "i", (int) param);
    if (py_retval == NULL) {
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    if (py_retval != Py_None) {
        PyErr_SetString(PyExc_TypeError, "function/method should return None");
        Py_DECREF(py_retval);
        if (PyEval_ThreadsInitialized())
            PyGILState_Release(__py_gil_state);
        return;
    }
    Py_DECREF(py_retval);
    if (PyEval_ThreadsInitialized())
        PyGILState_Release(__py_gil_state);
    return;
}

PyObject * foo_function_118(void);

short unsigned int foo_function_119(void);

int foo_function_120(void);

int32_t foo_function_121(void);

float foo_function_122(void);

long unsigned int foo_function_123(void);

char foo_function_124(void);

int16_t foo_function_125(void);

int64_t foo_function_126(void);

size_t foo_function_127(void);

unsigned short int foo_function_128(void);

Foo foo_function_129(void);

Foo & foo_function_130(void);

short int foo_function_131(void);

uint8_t foo_function_132(void);

unsigned short foo_function_133(void);

bool foo_function_134(void);

long long foo_function_135(void);

std::string foo_function_136(void);

void foo_function_137(void);

unsigned long foo_function_138(void);

unsigned int foo_function_139(void);

long long unsigned int foo_function_140(void);

short foo_function_141(void);

Foo * foo_function_142(void);

double foo_function_143(void);

uint32_t foo_function_144(void);

unsigned long long foo_function_145(void);

char * foo_function_146(void);

uint64_t foo_function_147(void);

uint16_t foo_function_148(void);

void foo_function_149(const PyObject * param_transfer);

void foo_function_150(const PyObject * param_notransfer);

void foo_function_151(PyObject * param_transfer);

void foo_function_152(PyObject * param_notransfer);

void foo_function_153(const int);

void foo_function_154(int);

void foo_function_155(const int32_t);

void foo_function_156(int32_t);

void foo_function_157(const int64_t);

void foo_function_158(int64_t);

void foo_function_159(const char);

void foo_function_160(char);

void foo_function_161(long long &);

void foo_function_162(const int16_t);

void foo_function_163(int16_t);

void foo_function_164(short &);

void foo_function_165(short &);

void foo_function_166(short &);

void foo_function_167(const size_t);

void foo_function_168(size_t);

void foo_function_169(const unsigned short int);

void foo_function_170(unsigned short int);

void foo_function_171(const Foo);

void foo_function_172(Foo);

void foo_function_173(unsigned long long &);

void foo_function_174(int &);

void foo_function_175(int &);

void foo_function_176(int &);

void foo_function_177(Foo &);

void foo_function_178(Foo &);

void foo_function_179(Foo &);

void foo_function_180(const short int);

void foo_function_181(short int);

void foo_function_182(const uint8_t);

void foo_function_183(uint8_t);

void foo_function_184(unsigned long &);

void foo_function_185(const std::string);

void foo_function_186(std::string);

void foo_function_187(const int *);

void foo_function_188(int *);

void foo_function_189(int *);

void foo_function_190(int *);

void foo_function_191(const uint32_t *);

void foo_function_192(uint32_t *);

void foo_function_193(uint32_t *);

void foo_function_194(uint32_t *);

void foo_function_195(bool &);

void foo_function_196(bool &);

void foo_function_197(bool &);

void foo_function_198(const unsigned short);

void foo_function_199(unsigned short);

void foo_function_200(const float *);

void foo_function_201(float *);

void foo_function_202(float *);

void foo_function_203(float *);

void foo_function_204(const bool);

void foo_function_205(bool);

void foo_function_206(const long long);

void foo_function_207(long long);

void foo_function_208(const Foo * param_transfer);

void foo_function_209(const Foo * param_notransfer);

void foo_function_210(Foo * param_transfer);

void foo_function_211(Foo * param_notransfer);

void foo_function_212(int64_t &);

void foo_function_213(const bool *);

void foo_function_214(bool *);

void foo_function_215(bool *);

void foo_function_216(bool *);

void foo_function_217(float &);

void foo_function_218(float &);

void foo_function_219(float &);

void foo_function_220(const float);

void foo_function_221(float);

void foo_function_222(uint64_t &);

void foo_function_223(const int8_t *);

void foo_function_224(int8_t *);

void foo_function_225(int8_t *);

void foo_function_226(int8_t *);

void foo_function_227(double &);

void foo_function_228(double &);

void foo_function_229(double &);

void foo_function_230(const unsigned long);

void foo_function_231(unsigned long);

void foo_function_232(short int &);

void foo_function_233(short int &);

void foo_function_234(short int &);

void foo_function_235(const unsigned int);

void foo_function_236(unsigned int);

void foo_function_237(const double *);

void foo_function_238(double *);

void foo_function_239(double *);

void foo_function_240(double *);

void foo_function_241(const short);

void foo_function_242(short);

void foo_function_243(int16_t &);

void foo_function_244(int16_t &);

void foo_function_245(int16_t &);

void foo_function_246(const unsigned int *);

void foo_function_247(unsigned int *);

void foo_function_248(unsigned int *);

void foo_function_249(unsigned int *);

void foo_function_250(std::string &);

void foo_function_251(std::string &);

void foo_function_252(std::string &);

void foo_function_253(const double);

void foo_function_254(double);

void foo_function_255(const uint8_t *);

void foo_function_256(uint8_t *);

void foo_function_257(uint8_t *);

void foo_function_258(uint8_t *);

void foo_function_259(const std::string *);

void foo_function_260(std::string *);

void foo_function_261(std::string *);

void foo_function_262(std::string *);

void foo_function_263(const uint32_t);

void foo_function_264(uint32_t);

void foo_function_265(const unsigned long long);

void foo_function_266(unsigned long long);

void foo_function_267(const char *);

void foo_function_268(char *);

void foo_function_269(const uint64_t);

void foo_function_270(uint64_t);

void foo_function_271(const uint16_t);

void foo_function_272(uint16_t);

/* --- module functions --- */


PyObject *
_wrap_foofoo_function_131()
{
    PyObject *py_retval;
    short int retval;

    retval = foo_function_131();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_131();


PyObject *
_wrap_foofoo_function_130()
{
    PyObject *py_retval;
    PyFoo *py_Foo;

    Foo & retval = foo_function_130();
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = new Foo(retval);
    py_retval = Py_BuildValue((char *) "N", py_Foo);
    return py_retval;
}
PyObject * _wrap_foofoo_function_130();


PyObject *
_wrap_foofoo_function_133()
{
    PyObject *py_retval;
    unsigned short retval;

    retval = foo_function_133();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_133();


PyObject *
_wrap_foofoo_function_132()
{
    PyObject *py_retval;
    uint8_t retval;

    retval = foo_function_132();
    py_retval = Py_BuildValue((char *) "i", (int)retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_132();


PyObject *
_wrap_foofoo_function_135()
{
    PyObject *py_retval;
    long long retval;

    retval = foo_function_135();
    py_retval = Py_BuildValue((char *) "L", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_135();


PyObject *
_wrap_foofoo_function_134()
{
    PyObject *py_retval;
    bool retval;

    retval = foo_function_134();
    py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(retval));
    return py_retval;
}
PyObject * _wrap_foofoo_function_134();


PyObject *
_wrap_foofoo_function_137()
{
    PyObject *py_retval;

    foo_function_137();
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_137();


PyObject *
_wrap_foofoo_function_136()
{
    PyObject *py_retval;
    std::string retval;

    retval = foo_function_136();
    py_retval = Py_BuildValue((char *) "s#", (retval).c_str(), (retval).size());
    return py_retval;
}
PyObject * _wrap_foofoo_function_136();


PyObject *
_wrap_foofoo_function_139()
{
    PyObject *py_retval;
    unsigned int retval;

    retval = foo_function_139();
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(retval));
    return py_retval;
}
PyObject * _wrap_foofoo_function_139();


PyObject *
_wrap_foofoo_function_138()
{
    PyObject *py_retval;
    unsigned long retval;

    retval = foo_function_138();
    py_retval = Py_BuildValue((char *) "k", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_138();


PyObject *
_wrap_foofoo_function_223(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int8_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "b", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_223(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_223(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_222(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_222(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_222(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_225()
{
    PyObject *py_retval;
    int8_t param_out;

    foo_function_225(&param_out);
    py_retval = Py_BuildValue((char *) "b", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_225();


PyObject *
_wrap_foofoo_function_224(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int8_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "b", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_224(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_224(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_227(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_227(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_227(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_226(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int8_t param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "b", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_226(&param_inout);
    py_retval = Py_BuildValue((char *) "b", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_226(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_249(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_249(&param_inout);
    py_retval = Py_BuildValue((char *) "I", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_249(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_248()
{
    PyObject *py_retval;
    unsigned int param_out;

    foo_function_248(&param_out);
    py_retval = Py_BuildValue((char *) "I", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_248();


PyObject *
_wrap_foofoo_function_144()
{
    PyObject *py_retval;
    uint32_t retval;

    retval = foo_function_144();
    py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(retval));
    return py_retval;
}
PyObject * _wrap_foofoo_function_144();


PyObject *
_wrap_foofoo_function_145()
{
    PyObject *py_retval;
    unsigned long long retval;

    retval = foo_function_145();
    py_retval = Py_BuildValue((char *) "K", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_145();


PyObject *
_wrap_foofoo_function_146()
{
    PyObject *py_retval;
    char *retval;

    retval = foo_function_146();
    py_retval = Py_BuildValue((char *) "s", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_146();


PyObject *
_wrap_foofoo_function_147()
{
    PyObject *py_retval;
    uint64_t retval;

    retval = foo_function_147();
    py_retval = Py_BuildValue((char *) "K", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_147();


PyObject *
_wrap_foofoo_function_140()
{
    PyObject *py_retval;
    long long unsigned int retval;

    retval = foo_function_140();
    py_retval = Py_BuildValue((char *) "K", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_140();


PyObject *
_wrap_foofoo_function_141()
{
    PyObject *py_retval;
    short retval;

    retval = foo_function_141();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_141();


PyObject *
_wrap_foofoo_function_142()
{
    PyObject *py_retval;
    Foo *retval;
    PyFoo *py_Foo;

    retval = foo_function_142();
    if (!(retval)) {
        Py_INCREF(Py_None);
        return Py_None;
    }
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->obj = retval;
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_retval = Py_BuildValue((char *) "N", py_Foo);
    return py_retval;
}
PyObject * _wrap_foofoo_function_142();


PyObject *
_wrap_foofoo_function_143()
{
    PyObject *py_retval;
    double retval;

    retval = foo_function_143();
    py_retval = Py_BuildValue((char *) "d", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_143();


PyObject *
_wrap_foofoo_function_254(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_254(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_254(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_255(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint8_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "B", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_255(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_255(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_256(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint8_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "B", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_256(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_256(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_240(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_240(&param_inout);
    py_retval = Py_BuildValue((char *) "d", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_240(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_148()
{
    PyObject *py_retval;
    uint16_t retval;

    retval = foo_function_148();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_148();


PyObject *
_wrap_foofoo_function_149(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyObject *param_transfer;
    const char *keywords[] = {"param_transfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &param_transfer)) {
        return NULL;
    }
    Py_INCREF((PyObject*) param_transfer);
    foo_function_149(param_transfer);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_149(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_252(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param_inout;
    Py_ssize_t param_inout_len;
    std::string param_inout_std;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param_inout, &param_inout_len)) {
        return NULL;
    }
    param_inout_std = std::string(param_inout, param_inout_len);
    foo_function_252(param_inout_std);
    py_retval = Py_BuildValue((char *) "s#", (param_inout_std).c_str(), (param_inout_std).size());
    return py_retval;
}
PyObject * _wrap_foofoo_function_252(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_253(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_253(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_253(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_230(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "k", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_230(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_230(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_241(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_241(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_241(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_157(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_157(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_157(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_156(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int32_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_156(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_156(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_155(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int32_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_155(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_155(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_154(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_154(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_154(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_153(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_153(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_153(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_152(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyObject *param_notransfer;
    const char *keywords[] = {"param_notransfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &param_notransfer)) {
        return NULL;
    }
    foo_function_152(param_notransfer);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_152(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_151(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyObject *param_transfer;
    const char *keywords[] = {"param_transfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &param_transfer)) {
        return NULL;
    }
    Py_INCREF((PyObject*) param_transfer);
    foo_function_151(param_transfer);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_151(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_150(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyObject *param_notransfer;
    const char *keywords[] = {"param_notransfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &param_notransfer)) {
        return NULL;
    }
    foo_function_150(param_notransfer);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_150(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_247(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_247(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_247(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_246(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_246(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_246(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_245()
{
    PyObject *py_retval;
    int16_t  param_out;

    foo_function_245(param_out);
    py_retval = Py_BuildValue((char *) "h", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_245();


PyObject *
_wrap_foofoo_function_244(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int16_t  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "h", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_244(param_inout);
    py_retval = Py_BuildValue((char *) "h", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_244(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_243(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int16_t  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "h", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_243(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_243(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_242(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_242(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_242(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_159(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    char param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "c", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_159(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_159(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_158(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_158(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_158(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_229(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_229(param_inout);
    py_retval = Py_BuildValue((char *) "d", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_229(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_228()
{
    PyObject *py_retval;
    double param_out;

    foo_function_228(param_out);
    py_retval = Py_BuildValue((char *) "d", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_228();


PyObject *
_wrap_foofoo_function_257()
{
    PyObject *py_retval;
    uint8_t param_out;

    foo_function_257(&param_out);
    py_retval = Py_BuildValue((char *) "B", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_257();


PyObject *
_wrap_foofoo_function_250(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param;
    Py_ssize_t param_len;
    std::string param_std;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param, &param_len)) {
        return NULL;
    }
    param_std = std::string(param, param_len);
    foo_function_250(param_std);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_250(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_251()
{
    PyObject *py_retval;
    const char *param_out;
    Py_ssize_t param_out_len;
    std::string param_out_std;

    foo_function_251(param_out_std);
    py_retval = Py_BuildValue((char *) "s#", (param_out_std).c_str(), (param_out_std).size());
    return py_retval;
}
PyObject * _wrap_foofoo_function_251();


PyObject *
_wrap_foofoo_function_162(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_162(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_162(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_163(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_163(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_163(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_160(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    char param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "c", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_160(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_160(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_161(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    long long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_161(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_161(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_166()
{
    PyObject *py_retval;
    short  param_out;

    foo_function_166(param_out);
    py_retval = Py_BuildValue((char *) "h", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_166();


PyObject *
_wrap_foofoo_function_167(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned PY_LONG_LONG param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_167(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_167(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_164(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    short  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "h", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_164(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_164(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_165(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    short  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "h", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_165(param_inout);
    py_retval = Py_BuildValue((char *) "h", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_165(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_272(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_272(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_272(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_168(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned PY_LONG_LONG param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_168(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_168(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_169(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_169(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_169(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_180(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_180(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_180(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_181(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_181(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_181(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_182(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_182(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_182(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_183(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_183(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_183(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_184(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "k", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_184(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_184(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_185(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param;
    Py_ssize_t param_len;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param, &param_len)) {
        return NULL;
    }
    foo_function_185(std::string(param, param_len));
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_185(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_186(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param;
    Py_ssize_t param_len;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param, &param_len)) {
        return NULL;
    }
    foo_function_186(std::string(param, param_len));
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_186(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_187(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_187(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_187(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_188(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_188(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_188(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_189()
{
    PyObject *py_retval;
    int  param_out;

    foo_function_189(&param_out);
    py_retval = Py_BuildValue((char *) "i", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_189();


PyObject *
_wrap_foofoo_function_179(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param_inout)) {
        return NULL;
    }
    foo_function_179(*param_inout->obj);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_179(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_178()
{
    PyObject *py_retval;
    PyFoo *param_out;

    param_out = PyObject_New(PyFoo, &PyFoo_Type);
    param_out->obj = new Foo();
    foo_function_178(*param_out->obj);
    param_out->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_retval = Py_BuildValue((char *) "N", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_178();


PyObject *
_wrap_foofoo_function_175()
{
    PyObject *py_retval;
    int  param_out;

    foo_function_175(param_out);
    py_retval = Py_BuildValue((char *) "i", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_175();


PyObject *
_wrap_foofoo_function_174(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_174(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_174(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_177(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param)) {
        return NULL;
    }
    foo_function_177(*((PyFoo *) param)->obj);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_177(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_176(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_176(param_inout);
    py_retval = Py_BuildValue((char *) "i", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_176(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_171(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param)) {
        return NULL;
    }
    foo_function_171(*((PyFoo *) param)->obj);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_171(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_170(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_170(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_170(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_173(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned long long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_173(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_173(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_172(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param)) {
        return NULL;
    }
    foo_function_172(*((PyFoo *) param)->obj);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_172(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_265(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned long long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_265(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_265(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_264(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_264(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_264(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_267(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    char *param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_267(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_267(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_266(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned long long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_266(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_266(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_261()
{
    PyObject *py_retval;
    const char *param_out;
    Py_ssize_t param_out_len;
    std::string param_out_std;

    foo_function_261(&param_out_std);
    py_retval = Py_BuildValue((char *) "s#", (param_out_std).c_str(), (param_out_std).size());
    return py_retval;
}
PyObject * _wrap_foofoo_function_261();


PyObject *
_wrap_foofoo_function_260(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param;
    Py_ssize_t param_len;
    std::string param_std;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param, &param_len)) {
        return NULL;
    }
    param_std = std::string(param, param_len);
    foo_function_260(&param_std);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_260(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_263(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_263(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_263(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_262(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param_inout;
    Py_ssize_t param_inout_len;
    std::string param_inout_std;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param_inout, &param_inout_len)) {
        return NULL;
    }
    param_inout_std = std::string(param_inout, param_inout_len);
    foo_function_262(&param_inout_std);
    py_retval = Py_BuildValue((char *) "s#", (param_inout_std).c_str(), (param_inout_std).size());
    return py_retval;
}
PyObject * _wrap_foofoo_function_262(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_269(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_269(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_269(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_268(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    char *param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_268(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_268(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_193()
{
    PyObject *py_retval;
    uint32_t param_out;

    foo_function_193(&param_out);
    py_retval = Py_BuildValue((char *) "I", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_193();


PyObject *
_wrap_foofoo_function_192(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint32_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_192(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_192(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_191(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint32_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_191(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_191(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_190(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_190(&param_inout);
    py_retval = Py_BuildValue((char *) "i", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_190(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_197(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool  param_inout;
    PyObject *py_param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param_inout)) {
        return NULL;
    }
    param_inout = PyObject_IsTrue(py_param_inout);
    foo_function_197(param_inout);
    py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(param_inout));
    return py_retval;
}
PyObject * _wrap_foofoo_function_197(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_196()
{
    PyObject *py_retval;
    bool  param_out;

    foo_function_196(param_out);
    py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(param_out));
    return py_retval;
}
PyObject * _wrap_foofoo_function_196();


PyObject *
_wrap_foofoo_function_195(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool  param;
    PyObject *py_param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param)) {
        return NULL;
    }
    param = PyObject_IsTrue(py_param);
    foo_function_195(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_195(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_194(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint32_t param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_194(&param_inout);
    py_retval = Py_BuildValue((char *) "I", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_194(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_258(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint8_t param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "B", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_258(&param_inout);
    py_retval = Py_BuildValue((char *) "B", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_258(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_199(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_199(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_199(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_198(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_198(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_198(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_238(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_238(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_238(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_239()
{
    PyObject *py_retval;
    double  param_out;

    foo_function_239(&param_out);
    py_retval = Py_BuildValue((char *) "d", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_239();


PyObject *
_wrap_foofoo_function_210(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param_transfer;
    Foo *param_transfer_ptr;
    const char *keywords[] = {"param_transfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param_transfer)) {
        return NULL;
    }
    param_transfer_ptr = (param_transfer ? param_transfer->obj : NULL);
    foo_function_210(param_transfer_ptr);
    if (param_transfer) {
        param_transfer->obj = NULL;
    }
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_210(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_211(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param_notransfer;
    Foo *param_notransfer_ptr;
    const char *keywords[] = {"param_notransfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param_notransfer)) {
        return NULL;
    }
    param_notransfer_ptr = (param_notransfer ? param_notransfer->obj : NULL);
    foo_function_211(param_notransfer_ptr);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_211(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_212(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_212(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_212(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_213(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool  param;
    PyObject *py_param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param)) {
        return NULL;
    }
    param = PyObject_IsTrue(py_param);
    foo_function_213(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_213(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_214(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool  param;
    PyObject *py_param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param)) {
        return NULL;
    }
    param = PyObject_IsTrue(py_param);
    foo_function_214(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_214(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_215()
{
    PyObject *py_retval;
    bool  param_out;

    foo_function_215(&param_out);
    py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(param_out));
    return py_retval;
}
PyObject * _wrap_foofoo_function_215();


PyObject *
_wrap_foofoo_function_216(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool  param_inout;
    PyObject *py_param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param_inout)) {
        return NULL;
    }
    param_inout = PyObject_IsTrue(py_param_inout);
    foo_function_216(&param_inout);
    py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(param_inout));
    return py_retval;
}
PyObject * _wrap_foofoo_function_216(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_217(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_217(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_217(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_218()
{
    PyObject *py_retval;
    float  param_out;

    foo_function_218(param_out);
    py_retval = Py_BuildValue((char *) "f", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_218();


PyObject *
_wrap_foofoo_function_219(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_219(param_inout);
    py_retval = Py_BuildValue((char *) "f", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_219(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_234()
{
    PyObject *py_retval;
    short int  param_out;

    foo_function_234(param_out);
    py_retval = Py_BuildValue((char *) "h", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_234();


PyObject *
_wrap_foofoo_function_220(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_220(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_220(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_231(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "k", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_231(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_231(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_119()
{
    PyObject *py_retval;
    short unsigned int retval;

    retval = foo_function_119();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_119();


PyObject *
_wrap_foofoo_function_118()
{
    PyObject *py_retval;
    PyObject *retval;

    retval = foo_function_118();
    py_retval = Py_BuildValue((char *) "N", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_118();


PyObject *
_wrap_foofoo_function_203(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_203(&param_inout);
    py_retval = Py_BuildValue((char *) "f", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_203(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_202()
{
    PyObject *py_retval;
    float  param_out;

    foo_function_202(&param_out);
    py_retval = Py_BuildValue((char *) "f", param_out);
    return py_retval;
}
PyObject * _wrap_foofoo_function_202();


PyObject *
_wrap_foofoo_function_201(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_201(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_201(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_200(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_200(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_200(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_207(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    long long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_207(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_207(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_206(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    long long param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_206(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_206(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_205(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool param;
    PyObject *py_param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param)) {
        return NULL;
    }
    param = (bool) PyObject_IsTrue(py_param);
    foo_function_205(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_205(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_204(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool param;
    PyObject *py_param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_param)) {
        return NULL;
    }
    param = (bool) PyObject_IsTrue(py_param);
    foo_function_204(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_204(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_209(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param_notransfer;
    Foo *param_notransfer_ptr;
    const char *keywords[] = {"param_notransfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param_notransfer)) {
        return NULL;
    }
    param_notransfer_ptr = (param_notransfer ? param_notransfer->obj : NULL);
    foo_function_209(param_notransfer_ptr);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_209(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_208(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    PyFoo *param_transfer;
    Foo *param_transfer_ptr;
    const char *keywords[] = {"param_transfer", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O!", (char **) keywords, &PyFoo_Type, &param_transfer)) {
        return NULL;
    }
    param_transfer_ptr = (param_transfer ? param_transfer->obj : NULL);
    foo_function_208(param_transfer_ptr);
    if (param_transfer) {
        param_transfer->obj = NULL;
    }
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_208(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_271(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i", (char **) keywords, &param)) {
        return NULL;
    }
    if (param > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    foo_function_271(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_271(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_270(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_270(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_270(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_126()
{
    PyObject *py_retval;
    int64_t retval;

    retval = foo_function_126();
    py_retval = Py_BuildValue((char *) "L", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_126();


PyObject *
_wrap_foofoo_function_127()
{
    PyObject *py_retval;
    size_t retval;

    retval = foo_function_127();
    py_retval = Py_BuildValue((char *) "K", ((unsigned PY_LONG_LONG) retval));
    return py_retval;
}
PyObject * _wrap_foofoo_function_127();


PyObject *
_wrap_foofoo_function_124()
{
    PyObject *py_retval;
    char retval;

    retval = foo_function_124();
    py_retval = Py_BuildValue((char *) "c", (int) retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_124();


PyObject *
_wrap_foofoo_function_125()
{
    PyObject *py_retval;
    int16_t retval;

    retval = foo_function_125();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_125();


PyObject *
_wrap_foofoo_function_122()
{
    PyObject *py_retval;
    float retval;

    retval = foo_function_122();
    py_retval = Py_BuildValue((char *) "f", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_122();


PyObject *
_wrap_foofoo_function_123()
{
    PyObject *py_retval;
    long unsigned int retval;

    retval = foo_function_123();
    py_retval = Py_BuildValue((char *) "k", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_123();


PyObject *
_wrap_foofoo_function_120()
{
    PyObject *py_retval;
    int retval;

    retval = foo_function_120();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_120();


PyObject *
_wrap_foofoo_function_121()
{
    PyObject *py_retval;
    int32_t retval;

    retval = foo_function_121();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_121();


PyObject *
_wrap_foofoo_function_236(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_236(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_236(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_237(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "d", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_237(&param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_237(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_221(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "f", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_221(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_221(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_235(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    unsigned int param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "I", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_235(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_235(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_232(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    short int  param;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "h", (char **) keywords, &param)) {
        return NULL;
    }
    foo_function_232(param);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_232(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_233(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    short int  param_inout;
    const char *keywords[] = {"param_inout", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "h", (char **) keywords, &param_inout)) {
        return NULL;
    }
    foo_function_233(param_inout);
    py_retval = Py_BuildValue((char *) "h", param_inout);
    return py_retval;
}
PyObject * _wrap_foofoo_function_233(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap_foofoo_function_128()
{
    PyObject *py_retval;
    unsigned short int retval;

    retval = foo_function_128();
    py_retval = Py_BuildValue((char *) "i", retval);
    return py_retval;
}
PyObject * _wrap_foofoo_function_128();


PyObject *
_wrap_foofoo_function_129()
{
    PyObject *py_retval;
    PyFoo *py_Foo;

    Foo retval = foo_function_129();
    py_Foo = PyObject_New(PyFoo, &PyFoo_Type);
    py_Foo->flags = PYBINDGEN_WRAPPER_FLAG_NONE;
    py_Foo->obj = new Foo(retval);
    py_retval = Py_BuildValue((char *) "N", py_Foo);
    return py_retval;
}
PyObject * _wrap_foofoo_function_129();


PyObject *
_wrap_foofoo_function_259(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    const char *param;
    Py_ssize_t param_len;
    std::string param_std;
    const char *keywords[] = {"param", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &param, &param_len)) {
        return NULL;
    }
    param_std = std::string(param, param_len);
    foo_function_259(&param_std);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap_foofoo_function_259(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);

static PyMethodDef foo_functions[] = {
    {(char *) "function_131", (PyCFunction) _wrap_foofoo_function_131, METH_NOARGS, NULL },
    {(char *) "function_130", (PyCFunction) _wrap_foofoo_function_130, METH_NOARGS, NULL },
    {(char *) "function_133", (PyCFunction) _wrap_foofoo_function_133, METH_NOARGS, NULL },
    {(char *) "function_132", (PyCFunction) _wrap_foofoo_function_132, METH_NOARGS, NULL },
    {(char *) "function_135", (PyCFunction) _wrap_foofoo_function_135, METH_NOARGS, NULL },
    {(char *) "function_134", (PyCFunction) _wrap_foofoo_function_134, METH_NOARGS, NULL },
    {(char *) "function_137", (PyCFunction) _wrap_foofoo_function_137, METH_NOARGS, NULL },
    {(char *) "function_136", (PyCFunction) _wrap_foofoo_function_136, METH_NOARGS, NULL },
    {(char *) "function_139", (PyCFunction) _wrap_foofoo_function_139, METH_NOARGS, NULL },
    {(char *) "function_138", (PyCFunction) _wrap_foofoo_function_138, METH_NOARGS, NULL },
    {(char *) "function_223", (PyCFunction) _wrap_foofoo_function_223, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_222", (PyCFunction) _wrap_foofoo_function_222, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_225", (PyCFunction) _wrap_foofoo_function_225, METH_NOARGS, NULL },
    {(char *) "function_224", (PyCFunction) _wrap_foofoo_function_224, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_227", (PyCFunction) _wrap_foofoo_function_227, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_226", (PyCFunction) _wrap_foofoo_function_226, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_249", (PyCFunction) _wrap_foofoo_function_249, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_248", (PyCFunction) _wrap_foofoo_function_248, METH_NOARGS, NULL },
    {(char *) "function_144", (PyCFunction) _wrap_foofoo_function_144, METH_NOARGS, NULL },
    {(char *) "function_145", (PyCFunction) _wrap_foofoo_function_145, METH_NOARGS, NULL },
    {(char *) "function_146", (PyCFunction) _wrap_foofoo_function_146, METH_NOARGS, NULL },
    {(char *) "function_147", (PyCFunction) _wrap_foofoo_function_147, METH_NOARGS, NULL },
    {(char *) "function_140", (PyCFunction) _wrap_foofoo_function_140, METH_NOARGS, NULL },
    {(char *) "function_141", (PyCFunction) _wrap_foofoo_function_141, METH_NOARGS, NULL },
    {(char *) "function_142", (PyCFunction) _wrap_foofoo_function_142, METH_NOARGS, NULL },
    {(char *) "function_143", (PyCFunction) _wrap_foofoo_function_143, METH_NOARGS, NULL },
    {(char *) "function_254", (PyCFunction) _wrap_foofoo_function_254, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_255", (PyCFunction) _wrap_foofoo_function_255, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_256", (PyCFunction) _wrap_foofoo_function_256, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_240", (PyCFunction) _wrap_foofoo_function_240, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_148", (PyCFunction) _wrap_foofoo_function_148, METH_NOARGS, NULL },
    {(char *) "function_149", (PyCFunction) _wrap_foofoo_function_149, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_252", (PyCFunction) _wrap_foofoo_function_252, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_253", (PyCFunction) _wrap_foofoo_function_253, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_230", (PyCFunction) _wrap_foofoo_function_230, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_241", (PyCFunction) _wrap_foofoo_function_241, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_157", (PyCFunction) _wrap_foofoo_function_157, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_156", (PyCFunction) _wrap_foofoo_function_156, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_155", (PyCFunction) _wrap_foofoo_function_155, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_154", (PyCFunction) _wrap_foofoo_function_154, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_153", (PyCFunction) _wrap_foofoo_function_153, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_152", (PyCFunction) _wrap_foofoo_function_152, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_151", (PyCFunction) _wrap_foofoo_function_151, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_150", (PyCFunction) _wrap_foofoo_function_150, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_247", (PyCFunction) _wrap_foofoo_function_247, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_246", (PyCFunction) _wrap_foofoo_function_246, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_245", (PyCFunction) _wrap_foofoo_function_245, METH_NOARGS, NULL },
    {(char *) "function_244", (PyCFunction) _wrap_foofoo_function_244, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_243", (PyCFunction) _wrap_foofoo_function_243, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_242", (PyCFunction) _wrap_foofoo_function_242, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_159", (PyCFunction) _wrap_foofoo_function_159, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_158", (PyCFunction) _wrap_foofoo_function_158, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_229", (PyCFunction) _wrap_foofoo_function_229, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_228", (PyCFunction) _wrap_foofoo_function_228, METH_NOARGS, NULL },
    {(char *) "function_257", (PyCFunction) _wrap_foofoo_function_257, METH_NOARGS, NULL },
    {(char *) "function_250", (PyCFunction) _wrap_foofoo_function_250, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_251", (PyCFunction) _wrap_foofoo_function_251, METH_NOARGS, NULL },
    {(char *) "function_162", (PyCFunction) _wrap_foofoo_function_162, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_163", (PyCFunction) _wrap_foofoo_function_163, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_160", (PyCFunction) _wrap_foofoo_function_160, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_161", (PyCFunction) _wrap_foofoo_function_161, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_166", (PyCFunction) _wrap_foofoo_function_166, METH_NOARGS, NULL },
    {(char *) "function_167", (PyCFunction) _wrap_foofoo_function_167, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_164", (PyCFunction) _wrap_foofoo_function_164, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_165", (PyCFunction) _wrap_foofoo_function_165, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_272", (PyCFunction) _wrap_foofoo_function_272, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_168", (PyCFunction) _wrap_foofoo_function_168, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_169", (PyCFunction) _wrap_foofoo_function_169, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_180", (PyCFunction) _wrap_foofoo_function_180, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_181", (PyCFunction) _wrap_foofoo_function_181, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_182", (PyCFunction) _wrap_foofoo_function_182, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_183", (PyCFunction) _wrap_foofoo_function_183, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_184", (PyCFunction) _wrap_foofoo_function_184, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_185", (PyCFunction) _wrap_foofoo_function_185, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_186", (PyCFunction) _wrap_foofoo_function_186, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_187", (PyCFunction) _wrap_foofoo_function_187, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_188", (PyCFunction) _wrap_foofoo_function_188, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_189", (PyCFunction) _wrap_foofoo_function_189, METH_NOARGS, NULL },
    {(char *) "function_179", (PyCFunction) _wrap_foofoo_function_179, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_178", (PyCFunction) _wrap_foofoo_function_178, METH_NOARGS, NULL },
    {(char *) "function_175", (PyCFunction) _wrap_foofoo_function_175, METH_NOARGS, NULL },
    {(char *) "function_174", (PyCFunction) _wrap_foofoo_function_174, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_177", (PyCFunction) _wrap_foofoo_function_177, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_176", (PyCFunction) _wrap_foofoo_function_176, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_171", (PyCFunction) _wrap_foofoo_function_171, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_170", (PyCFunction) _wrap_foofoo_function_170, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_173", (PyCFunction) _wrap_foofoo_function_173, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_172", (PyCFunction) _wrap_foofoo_function_172, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_265", (PyCFunction) _wrap_foofoo_function_265, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_264", (PyCFunction) _wrap_foofoo_function_264, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_267", (PyCFunction) _wrap_foofoo_function_267, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_266", (PyCFunction) _wrap_foofoo_function_266, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_261", (PyCFunction) _wrap_foofoo_function_261, METH_NOARGS, NULL },
    {(char *) "function_260", (PyCFunction) _wrap_foofoo_function_260, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_263", (PyCFunction) _wrap_foofoo_function_263, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_262", (PyCFunction) _wrap_foofoo_function_262, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_269", (PyCFunction) _wrap_foofoo_function_269, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_268", (PyCFunction) _wrap_foofoo_function_268, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_193", (PyCFunction) _wrap_foofoo_function_193, METH_NOARGS, NULL },
    {(char *) "function_192", (PyCFunction) _wrap_foofoo_function_192, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_191", (PyCFunction) _wrap_foofoo_function_191, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_190", (PyCFunction) _wrap_foofoo_function_190, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_197", (PyCFunction) _wrap_foofoo_function_197, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_196", (PyCFunction) _wrap_foofoo_function_196, METH_NOARGS, NULL },
    {(char *) "function_195", (PyCFunction) _wrap_foofoo_function_195, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_194", (PyCFunction) _wrap_foofoo_function_194, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_258", (PyCFunction) _wrap_foofoo_function_258, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_199", (PyCFunction) _wrap_foofoo_function_199, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_198", (PyCFunction) _wrap_foofoo_function_198, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_238", (PyCFunction) _wrap_foofoo_function_238, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_239", (PyCFunction) _wrap_foofoo_function_239, METH_NOARGS, NULL },
    {(char *) "function_210", (PyCFunction) _wrap_foofoo_function_210, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_211", (PyCFunction) _wrap_foofoo_function_211, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_212", (PyCFunction) _wrap_foofoo_function_212, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_213", (PyCFunction) _wrap_foofoo_function_213, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_214", (PyCFunction) _wrap_foofoo_function_214, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_215", (PyCFunction) _wrap_foofoo_function_215, METH_NOARGS, NULL },
    {(char *) "function_216", (PyCFunction) _wrap_foofoo_function_216, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_217", (PyCFunction) _wrap_foofoo_function_217, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_218", (PyCFunction) _wrap_foofoo_function_218, METH_NOARGS, NULL },
    {(char *) "function_219", (PyCFunction) _wrap_foofoo_function_219, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_234", (PyCFunction) _wrap_foofoo_function_234, METH_NOARGS, NULL },
    {(char *) "function_220", (PyCFunction) _wrap_foofoo_function_220, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_231", (PyCFunction) _wrap_foofoo_function_231, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_119", (PyCFunction) _wrap_foofoo_function_119, METH_NOARGS, NULL },
    {(char *) "function_118", (PyCFunction) _wrap_foofoo_function_118, METH_NOARGS, NULL },
    {(char *) "function_203", (PyCFunction) _wrap_foofoo_function_203, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_202", (PyCFunction) _wrap_foofoo_function_202, METH_NOARGS, NULL },
    {(char *) "function_201", (PyCFunction) _wrap_foofoo_function_201, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_200", (PyCFunction) _wrap_foofoo_function_200, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_207", (PyCFunction) _wrap_foofoo_function_207, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_206", (PyCFunction) _wrap_foofoo_function_206, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_205", (PyCFunction) _wrap_foofoo_function_205, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_204", (PyCFunction) _wrap_foofoo_function_204, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_209", (PyCFunction) _wrap_foofoo_function_209, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_208", (PyCFunction) _wrap_foofoo_function_208, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_271", (PyCFunction) _wrap_foofoo_function_271, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_270", (PyCFunction) _wrap_foofoo_function_270, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_126", (PyCFunction) _wrap_foofoo_function_126, METH_NOARGS, NULL },
    {(char *) "function_127", (PyCFunction) _wrap_foofoo_function_127, METH_NOARGS, NULL },
    {(char *) "function_124", (PyCFunction) _wrap_foofoo_function_124, METH_NOARGS, NULL },
    {(char *) "function_125", (PyCFunction) _wrap_foofoo_function_125, METH_NOARGS, NULL },
    {(char *) "function_122", (PyCFunction) _wrap_foofoo_function_122, METH_NOARGS, NULL },
    {(char *) "function_123", (PyCFunction) _wrap_foofoo_function_123, METH_NOARGS, NULL },
    {(char *) "function_120", (PyCFunction) _wrap_foofoo_function_120, METH_NOARGS, NULL },
    {(char *) "function_121", (PyCFunction) _wrap_foofoo_function_121, METH_NOARGS, NULL },
    {(char *) "function_236", (PyCFunction) _wrap_foofoo_function_236, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_237", (PyCFunction) _wrap_foofoo_function_237, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_221", (PyCFunction) _wrap_foofoo_function_221, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_235", (PyCFunction) _wrap_foofoo_function_235, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_232", (PyCFunction) _wrap_foofoo_function_232, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_233", (PyCFunction) _wrap_foofoo_function_233, METH_KEYWORDS|METH_VARARGS, NULL },
    {(char *) "function_128", (PyCFunction) _wrap_foofoo_function_128, METH_NOARGS, NULL },
    {(char *) "function_129", (PyCFunction) _wrap_foofoo_function_129, METH_NOARGS, NULL },
    {(char *) "function_259", (PyCFunction) _wrap_foofoo_function_259, METH_KEYWORDS|METH_VARARGS, NULL },
    {NULL, NULL, 0, NULL}
};


PyMODINIT_FUNC
#if defined(__GNUC__) && __GNUC__ >= 4
__attribute__ ((visibility("default")))
#endif
initfoo(void)
{
    PyObject *m;
    m = Py_InitModule3((char *) "foo", foo_functions, NULL);
    if (m == NULL) {
        return;
    }
}
