/* This file was generated by PyBindGen 0.0.0.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


#ifndef PyVarObject_HEAD_INIT
#define PyVarObject_HEAD_INIT(type, size) \
        PyObject_HEAD_INIT(type) size,
#endif


#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX >= 0x03050000
typedef PyAsyncMethods* cmpfunc;
#else
typedef void* cmpfunc;
#endif
#define PyCObject_FromVoidPtr(a, b) PyCapsule_New(a, NULL, b)
#define PyCObject_AsVoidPtr(a) PyCapsule_GetPointer(a, NULL)
#define PyString_FromString(a) PyBytes_FromString(a)
#define Py_TPFLAGS_CHECKTYPES 0 /* this flag doesn't exist in python 3 */
#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__ */

#ifndef _PyBindGenWrapperFlags_defined_
#define _PyBindGenWrapperFlags_defined_
typedef enum _PyBindGenWrapperFlags {
   PYBINDGEN_WRAPPER_FLAG_NONE = 0,
   PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED = (1<<0),
} PyBindGenWrapperFlags;
#endif


#include "goodbc_python_go_go.h"
/* --- module functions --- */


PyObject *
_wrap__goodbc_python_go_GoPyInit()
{
    PyObject *py_retval;

    GoPyInit();
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_GoPyInit();


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

    retval = Slice_bool_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_bool_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_bool_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_bool_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_bool_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_bool_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_bool_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(retval));
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_bool_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_bool_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    bool value;
    PyObject *py_value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LiO", (char **) keywords, &handle, &idx, &py_value)) {
        return NULL;
    }
    value = (bool) PyObject_IsTrue(py_value);
    Slice_bool_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_bool_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_bool_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    bool value;
    PyObject *py_value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LO", (char **) keywords, &handle, &py_value)) {
        return NULL;
    }
    value = (bool) PyObject_IsTrue(py_value);
    Slice_bool_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_bool_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_byte_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_byte_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_byte_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_byte_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_byte_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_byte_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint8_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_byte_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", (int)retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_byte_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_byte_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    if (value > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_byte_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_byte_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_byte_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    if (value > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_byte_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_byte_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_float32_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float32_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_float32_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_float32_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float32_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_float32_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    float retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_float32_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "f", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float32_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_float32_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    float value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lif", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_float32_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float32_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_float32_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    float value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lf", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_float32_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float32_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_float64_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float64_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_float64_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_float64_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float64_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_float64_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    double retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_float64_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "d", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float64_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_float64_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    double value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lid", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_float64_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float64_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_float64_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    double value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Ld", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_float64_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_float64_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_int_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_int_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_int_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_int_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int64_t value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LiL", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_int_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LL", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_int_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_int16_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int16_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_int16_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_int16_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int16_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int16_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int16_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_int16_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int16_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int16_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    if (value > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_int16_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int16_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int16_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    if (value > 0x7fff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_int16_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int16_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_int32_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int32_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_int32_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_int32_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int32_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int32_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int32_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_int32_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int32_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int32_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int32_t value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_int32_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int32_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int32_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int32_t value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_int32_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int32_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_int64_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int64_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_int64_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_int64_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int64_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int64_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_int64_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int64_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int64_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int64_t value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LiL", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_int64_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int64_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LL", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_int64_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int64_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_int8_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int8_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_int8_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_int8_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int8_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int8_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int8_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_int8_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int8_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int8_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    if (value > 0x7f) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_int8_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int8_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_int8_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    if (value > 0x7f) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_int8_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_int8_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_rune_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_rune_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_rune_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_rune_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_rune_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_rune_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int32_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_rune_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_rune_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_rune_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int32_t value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_rune_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_rune_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_rune_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int32_t value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_rune_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_rune_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_string_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_string_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_string_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_string_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_string_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_string_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    char *retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_string_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "s", retval);
    }
    free(retval);

    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_string_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_string_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    char *value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lis", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_string_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_string_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Ls", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_string_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_string_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_uint_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_uint_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_uint_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_uint_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "K", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    uint64_t value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LiK", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_uint_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    uint64_t value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LK", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_uint_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_uint16_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint16_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_uint16_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_uint16_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint16_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint16_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint16_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_uint16_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint16_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint16_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    if (value > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_uint16_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint16_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint16_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    if (value > 0xffff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_uint16_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint16_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_uint32_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint32_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_uint32_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_uint32_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint32_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint32_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint32_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_uint32_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "N", PyLong_FromUnsignedLong(retval));
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint32_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint32_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    unsigned int value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LiI", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_uint32_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint32_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint32_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    unsigned int value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LI", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_uint32_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint32_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_uint64_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint64_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_uint64_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_uint64_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint64_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint64_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_uint64_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "K", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint64_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint64_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    uint64_t value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LiK", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    Slice_uint64_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint64_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint64_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    uint64_t value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "LK", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    Slice_uint64_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint64_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = Slice_uint8_CTor();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint8_CTor();


PyObject *
_wrap__goodbc_python_go_Slice_uint8_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int retval;
    int64_t handle;
    const char *keywords[] = {"handle", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "L", (char **) keywords, &handle)) {
        return NULL;
    }
    retval = Slice_uint8_len(handle);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint8_len(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint8_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint8_t retval;
    int64_t handle;
    int idx;
    const char *keywords[] = {"handle", "idx", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &idx)) {
        return NULL;
    }
    retval = Slice_uint8_elem(handle, idx);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "i", (int)retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint8_elem(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint8_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int idx;
    int value;
    const char *keywords[] = {"handle", "idx", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Lii", (char **) keywords, &handle, &idx, &value)) {
        return NULL;
    }
    if (value > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_uint8_set(handle, idx, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint8_set(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_Slice_uint8_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t handle;
    int value;
    const char *keywords[] = {"handle", "value", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Li", (char **) keywords, &handle, &value)) {
        return NULL;
    }
    if (value > 0xff) {
        PyErr_SetString(PyExc_ValueError, "Out of range");
        return NULL;
    }
    Slice_uint8_append(handle, value);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_Slice_uint8_append(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &sessionID)) {
        return NULL;
    }
    retval = goodbc_python_go_RPCConnect(sessionID);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "s", retval);
    }
    free(retval);

    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_RPCConnect(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_goodbc_python_go_RPCExecute(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t retval;
    uint64_t sessionID;
    char *query;
    const char *keywords[] = {"sessionID", "query", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Ks", (char **) keywords, &sessionID, &query)) {
        return NULL;
    }
    retval = goodbc_python_go_RPCExecute(sessionID, query);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "K", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_RPCExecute(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_goodbc_python_go_RPCFetchAll(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    char *retval;
    uint64_t sessionID;
    uint64_t rowsID;
    const char *keywords[] = {"sessionID", "rowsID", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "KK", (char **) keywords, &sessionID, &rowsID)) {
        return NULL;
    }
    retval = goodbc_python_go_RPCFetchAll(sessionID, rowsID);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "s", retval);
    }
    free(retval);

    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_RPCFetchAll(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_goodbc_python_go_RPCQuery(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    uint64_t retval;
    uint64_t sessionID;
    char *query;
    const char *keywords[] = {"sessionID", "query", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "Ks", (char **) keywords, &sessionID, &query)) {
        return NULL;
    }
    retval = goodbc_python_go_RPCQuery(sessionID, query);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "K", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_RPCQuery(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_goodbc_python_go_SetPyPy(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    bool goRun;
    PyObject *py_goRun;
    const char *keywords[] = {"goRun", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "O", (char **) keywords, &py_goRun)) {
        return NULL;
    }
    goRun = (bool) PyObject_IsTrue(py_goRun);
    goodbc_python_go_SetPyPy(goRun);
    Py_INCREF(Py_None);
    py_retval = Py_None;
    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_SetPyPy(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    retval = goodbc_python_go_GetPyPy();
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "N", PyBool_FromLong(retval));
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_GetPyPy();


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

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s", (char **) keywords, &dataSourceName)) {
        return NULL;
    }
    retval = goodbc_python_go_NewRPCSession(dataSourceName);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "K", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_NewRPCSession(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


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

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "K", (char **) keywords, &sessionID)) {
        return NULL;
    }
    retval = goodbc_python_go_RPCClose(sessionID);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "s", retval);
    }
    free(retval);

    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_RPCClose(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);


PyObject *
_wrap__goodbc_python_go_goodbc_python_go_RPCGetRowsAffected(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs)
{
    PyObject *py_retval;
    int64_t retval;
    uint64_t sessionID;
    uint64_t resultID;
    const char *keywords[] = {"sessionID", "resultID", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "KK", (char **) keywords, &sessionID, &resultID)) {
        return NULL;
    }
    retval = goodbc_python_go_RPCGetRowsAffected(sessionID, resultID);
    if (PyErr_Occurred() != NULL) {
        py_retval = NULL;
    } else {
        py_retval = Py_BuildValue((char *) "L", retval);
    }


    return py_retval;
}
PyObject * _wrap__goodbc_python_go_goodbc_python_go_RPCGetRowsAffected(PyObject * PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs);

static PyMethodDef _goodbc_python_go_functions[] = {
    {(char *) "GoPyInit", (PyCFunction) _wrap__goodbc_python_go_GoPyInit, METH_NOARGS, "GoPyInit()\n\n" },
    {(char *) "Slice_bool_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_bool_CTor, METH_NOARGS, "Slice_bool_CTor()\n\n" },
    {(char *) "Slice_bool_len", (PyCFunction) _wrap__goodbc_python_go_Slice_bool_len, METH_KEYWORDS|METH_VARARGS, "Slice_bool_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_bool_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_bool_elem, METH_KEYWORDS|METH_VARARGS, "Slice_bool_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_bool_set", (PyCFunction) _wrap__goodbc_python_go_Slice_bool_set, METH_KEYWORDS|METH_VARARGS, "Slice_bool_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: bool" },
    {(char *) "Slice_bool_append", (PyCFunction) _wrap__goodbc_python_go_Slice_bool_append, METH_KEYWORDS|METH_VARARGS, "Slice_bool_append(handle, value)\n\ntype: handle: int64_t\ntype: value: bool" },
    {(char *) "Slice_byte_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_byte_CTor, METH_NOARGS, "Slice_byte_CTor()\n\n" },
    {(char *) "Slice_byte_len", (PyCFunction) _wrap__goodbc_python_go_Slice_byte_len, METH_KEYWORDS|METH_VARARGS, "Slice_byte_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_byte_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_byte_elem, METH_KEYWORDS|METH_VARARGS, "Slice_byte_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_byte_set", (PyCFunction) _wrap__goodbc_python_go_Slice_byte_set, METH_KEYWORDS|METH_VARARGS, "Slice_byte_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: uint8_t" },
    {(char *) "Slice_byte_append", (PyCFunction) _wrap__goodbc_python_go_Slice_byte_append, METH_KEYWORDS|METH_VARARGS, "Slice_byte_append(handle, value)\n\ntype: handle: int64_t\ntype: value: uint8_t" },
    {(char *) "Slice_float32_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_float32_CTor, METH_NOARGS, "Slice_float32_CTor()\n\n" },
    {(char *) "Slice_float32_len", (PyCFunction) _wrap__goodbc_python_go_Slice_float32_len, METH_KEYWORDS|METH_VARARGS, "Slice_float32_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_float32_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_float32_elem, METH_KEYWORDS|METH_VARARGS, "Slice_float32_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_float32_set", (PyCFunction) _wrap__goodbc_python_go_Slice_float32_set, METH_KEYWORDS|METH_VARARGS, "Slice_float32_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: float" },
    {(char *) "Slice_float32_append", (PyCFunction) _wrap__goodbc_python_go_Slice_float32_append, METH_KEYWORDS|METH_VARARGS, "Slice_float32_append(handle, value)\n\ntype: handle: int64_t\ntype: value: float" },
    {(char *) "Slice_float64_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_float64_CTor, METH_NOARGS, "Slice_float64_CTor()\n\n" },
    {(char *) "Slice_float64_len", (PyCFunction) _wrap__goodbc_python_go_Slice_float64_len, METH_KEYWORDS|METH_VARARGS, "Slice_float64_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_float64_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_float64_elem, METH_KEYWORDS|METH_VARARGS, "Slice_float64_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_float64_set", (PyCFunction) _wrap__goodbc_python_go_Slice_float64_set, METH_KEYWORDS|METH_VARARGS, "Slice_float64_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: double" },
    {(char *) "Slice_float64_append", (PyCFunction) _wrap__goodbc_python_go_Slice_float64_append, METH_KEYWORDS|METH_VARARGS, "Slice_float64_append(handle, value)\n\ntype: handle: int64_t\ntype: value: double" },
    {(char *) "Slice_int_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_int_CTor, METH_NOARGS, "Slice_int_CTor()\n\n" },
    {(char *) "Slice_int_len", (PyCFunction) _wrap__goodbc_python_go_Slice_int_len, METH_KEYWORDS|METH_VARARGS, "Slice_int_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_int_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_int_elem, METH_KEYWORDS|METH_VARARGS, "Slice_int_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_int_set", (PyCFunction) _wrap__goodbc_python_go_Slice_int_set, METH_KEYWORDS|METH_VARARGS, "Slice_int_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: int64_t" },
    {(char *) "Slice_int_append", (PyCFunction) _wrap__goodbc_python_go_Slice_int_append, METH_KEYWORDS|METH_VARARGS, "Slice_int_append(handle, value)\n\ntype: handle: int64_t\ntype: value: int64_t" },
    {(char *) "Slice_int16_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_int16_CTor, METH_NOARGS, "Slice_int16_CTor()\n\n" },
    {(char *) "Slice_int16_len", (PyCFunction) _wrap__goodbc_python_go_Slice_int16_len, METH_KEYWORDS|METH_VARARGS, "Slice_int16_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_int16_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_int16_elem, METH_KEYWORDS|METH_VARARGS, "Slice_int16_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_int16_set", (PyCFunction) _wrap__goodbc_python_go_Slice_int16_set, METH_KEYWORDS|METH_VARARGS, "Slice_int16_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: int16_t" },
    {(char *) "Slice_int16_append", (PyCFunction) _wrap__goodbc_python_go_Slice_int16_append, METH_KEYWORDS|METH_VARARGS, "Slice_int16_append(handle, value)\n\ntype: handle: int64_t\ntype: value: int16_t" },
    {(char *) "Slice_int32_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_int32_CTor, METH_NOARGS, "Slice_int32_CTor()\n\n" },
    {(char *) "Slice_int32_len", (PyCFunction) _wrap__goodbc_python_go_Slice_int32_len, METH_KEYWORDS|METH_VARARGS, "Slice_int32_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_int32_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_int32_elem, METH_KEYWORDS|METH_VARARGS, "Slice_int32_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_int32_set", (PyCFunction) _wrap__goodbc_python_go_Slice_int32_set, METH_KEYWORDS|METH_VARARGS, "Slice_int32_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: int32_t" },
    {(char *) "Slice_int32_append", (PyCFunction) _wrap__goodbc_python_go_Slice_int32_append, METH_KEYWORDS|METH_VARARGS, "Slice_int32_append(handle, value)\n\ntype: handle: int64_t\ntype: value: int32_t" },
    {(char *) "Slice_int64_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_int64_CTor, METH_NOARGS, "Slice_int64_CTor()\n\n" },
    {(char *) "Slice_int64_len", (PyCFunction) _wrap__goodbc_python_go_Slice_int64_len, METH_KEYWORDS|METH_VARARGS, "Slice_int64_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_int64_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_int64_elem, METH_KEYWORDS|METH_VARARGS, "Slice_int64_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_int64_set", (PyCFunction) _wrap__goodbc_python_go_Slice_int64_set, METH_KEYWORDS|METH_VARARGS, "Slice_int64_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: int64_t" },
    {(char *) "Slice_int64_append", (PyCFunction) _wrap__goodbc_python_go_Slice_int64_append, METH_KEYWORDS|METH_VARARGS, "Slice_int64_append(handle, value)\n\ntype: handle: int64_t\ntype: value: int64_t" },
    {(char *) "Slice_int8_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_int8_CTor, METH_NOARGS, "Slice_int8_CTor()\n\n" },
    {(char *) "Slice_int8_len", (PyCFunction) _wrap__goodbc_python_go_Slice_int8_len, METH_KEYWORDS|METH_VARARGS, "Slice_int8_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_int8_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_int8_elem, METH_KEYWORDS|METH_VARARGS, "Slice_int8_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_int8_set", (PyCFunction) _wrap__goodbc_python_go_Slice_int8_set, METH_KEYWORDS|METH_VARARGS, "Slice_int8_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: int8_t" },
    {(char *) "Slice_int8_append", (PyCFunction) _wrap__goodbc_python_go_Slice_int8_append, METH_KEYWORDS|METH_VARARGS, "Slice_int8_append(handle, value)\n\ntype: handle: int64_t\ntype: value: int8_t" },
    {(char *) "Slice_rune_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_rune_CTor, METH_NOARGS, "Slice_rune_CTor()\n\n" },
    {(char *) "Slice_rune_len", (PyCFunction) _wrap__goodbc_python_go_Slice_rune_len, METH_KEYWORDS|METH_VARARGS, "Slice_rune_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_rune_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_rune_elem, METH_KEYWORDS|METH_VARARGS, "Slice_rune_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_rune_set", (PyCFunction) _wrap__goodbc_python_go_Slice_rune_set, METH_KEYWORDS|METH_VARARGS, "Slice_rune_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: int32_t" },
    {(char *) "Slice_rune_append", (PyCFunction) _wrap__goodbc_python_go_Slice_rune_append, METH_KEYWORDS|METH_VARARGS, "Slice_rune_append(handle, value)\n\ntype: handle: int64_t\ntype: value: int32_t" },
    {(char *) "Slice_string_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_string_CTor, METH_NOARGS, "Slice_string_CTor()\n\n" },
    {(char *) "Slice_string_len", (PyCFunction) _wrap__goodbc_python_go_Slice_string_len, METH_KEYWORDS|METH_VARARGS, "Slice_string_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_string_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_string_elem, METH_KEYWORDS|METH_VARARGS, "Slice_string_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_string_set", (PyCFunction) _wrap__goodbc_python_go_Slice_string_set, METH_KEYWORDS|METH_VARARGS, "Slice_string_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: char *" },
    {(char *) "Slice_string_append", (PyCFunction) _wrap__goodbc_python_go_Slice_string_append, METH_KEYWORDS|METH_VARARGS, "Slice_string_append(handle, value)\n\ntype: handle: int64_t\ntype: value: char *" },
    {(char *) "Slice_uint_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_uint_CTor, METH_NOARGS, "Slice_uint_CTor()\n\n" },
    {(char *) "Slice_uint_len", (PyCFunction) _wrap__goodbc_python_go_Slice_uint_len, METH_KEYWORDS|METH_VARARGS, "Slice_uint_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_uint_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_uint_elem, METH_KEYWORDS|METH_VARARGS, "Slice_uint_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_uint_set", (PyCFunction) _wrap__goodbc_python_go_Slice_uint_set, METH_KEYWORDS|METH_VARARGS, "Slice_uint_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: uint64_t" },
    {(char *) "Slice_uint_append", (PyCFunction) _wrap__goodbc_python_go_Slice_uint_append, METH_KEYWORDS|METH_VARARGS, "Slice_uint_append(handle, value)\n\ntype: handle: int64_t\ntype: value: uint64_t" },
    {(char *) "Slice_uint16_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_uint16_CTor, METH_NOARGS, "Slice_uint16_CTor()\n\n" },
    {(char *) "Slice_uint16_len", (PyCFunction) _wrap__goodbc_python_go_Slice_uint16_len, METH_KEYWORDS|METH_VARARGS, "Slice_uint16_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_uint16_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_uint16_elem, METH_KEYWORDS|METH_VARARGS, "Slice_uint16_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_uint16_set", (PyCFunction) _wrap__goodbc_python_go_Slice_uint16_set, METH_KEYWORDS|METH_VARARGS, "Slice_uint16_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: uint16_t" },
    {(char *) "Slice_uint16_append", (PyCFunction) _wrap__goodbc_python_go_Slice_uint16_append, METH_KEYWORDS|METH_VARARGS, "Slice_uint16_append(handle, value)\n\ntype: handle: int64_t\ntype: value: uint16_t" },
    {(char *) "Slice_uint32_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_uint32_CTor, METH_NOARGS, "Slice_uint32_CTor()\n\n" },
    {(char *) "Slice_uint32_len", (PyCFunction) _wrap__goodbc_python_go_Slice_uint32_len, METH_KEYWORDS|METH_VARARGS, "Slice_uint32_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_uint32_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_uint32_elem, METH_KEYWORDS|METH_VARARGS, "Slice_uint32_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_uint32_set", (PyCFunction) _wrap__goodbc_python_go_Slice_uint32_set, METH_KEYWORDS|METH_VARARGS, "Slice_uint32_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: uint32_t" },
    {(char *) "Slice_uint32_append", (PyCFunction) _wrap__goodbc_python_go_Slice_uint32_append, METH_KEYWORDS|METH_VARARGS, "Slice_uint32_append(handle, value)\n\ntype: handle: int64_t\ntype: value: uint32_t" },
    {(char *) "Slice_uint64_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_uint64_CTor, METH_NOARGS, "Slice_uint64_CTor()\n\n" },
    {(char *) "Slice_uint64_len", (PyCFunction) _wrap__goodbc_python_go_Slice_uint64_len, METH_KEYWORDS|METH_VARARGS, "Slice_uint64_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_uint64_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_uint64_elem, METH_KEYWORDS|METH_VARARGS, "Slice_uint64_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_uint64_set", (PyCFunction) _wrap__goodbc_python_go_Slice_uint64_set, METH_KEYWORDS|METH_VARARGS, "Slice_uint64_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: uint64_t" },
    {(char *) "Slice_uint64_append", (PyCFunction) _wrap__goodbc_python_go_Slice_uint64_append, METH_KEYWORDS|METH_VARARGS, "Slice_uint64_append(handle, value)\n\ntype: handle: int64_t\ntype: value: uint64_t" },
    {(char *) "Slice_uint8_CTor", (PyCFunction) _wrap__goodbc_python_go_Slice_uint8_CTor, METH_NOARGS, "Slice_uint8_CTor()\n\n" },
    {(char *) "Slice_uint8_len", (PyCFunction) _wrap__goodbc_python_go_Slice_uint8_len, METH_KEYWORDS|METH_VARARGS, "Slice_uint8_len(handle)\n\ntype: handle: int64_t" },
    {(char *) "Slice_uint8_elem", (PyCFunction) _wrap__goodbc_python_go_Slice_uint8_elem, METH_KEYWORDS|METH_VARARGS, "Slice_uint8_elem(handle, idx)\n\ntype: handle: int64_t\ntype: idx: int" },
    {(char *) "Slice_uint8_set", (PyCFunction) _wrap__goodbc_python_go_Slice_uint8_set, METH_KEYWORDS|METH_VARARGS, "Slice_uint8_set(handle, idx, value)\n\ntype: handle: int64_t\ntype: idx: int\ntype: value: uint8_t" },
    {(char *) "Slice_uint8_append", (PyCFunction) _wrap__goodbc_python_go_Slice_uint8_append, METH_KEYWORDS|METH_VARARGS, "Slice_uint8_append(handle, value)\n\ntype: handle: int64_t\ntype: value: uint8_t" },
    {(char *) "goodbc_python_go_RPCConnect", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_RPCConnect, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_RPCConnect(sessionID)\n\ntype: sessionID: uint64_t" },
    {(char *) "goodbc_python_go_RPCExecute", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_RPCExecute, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_RPCExecute(sessionID, query)\n\ntype: sessionID: uint64_t\ntype: query: char *" },
    {(char *) "goodbc_python_go_RPCFetchAll", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_RPCFetchAll, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_RPCFetchAll(sessionID, rowsID)\n\ntype: sessionID: uint64_t\ntype: rowsID: uint64_t" },
    {(char *) "goodbc_python_go_RPCQuery", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_RPCQuery, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_RPCQuery(sessionID, query)\n\ntype: sessionID: uint64_t\ntype: query: char *" },
    {(char *) "goodbc_python_go_SetPyPy", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_SetPyPy, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_SetPyPy(goRun)\n\ntype: goRun: bool" },
    {(char *) "goodbc_python_go_GetPyPy", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_GetPyPy, METH_NOARGS, "goodbc_python_go_GetPyPy()\n\n" },
    {(char *) "goodbc_python_go_NewRPCSession", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_NewRPCSession, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_NewRPCSession(dataSourceName)\n\ntype: dataSourceName: char *" },
    {(char *) "goodbc_python_go_RPCClose", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_RPCClose, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_RPCClose(sessionID)\n\ntype: sessionID: uint64_t" },
    {(char *) "goodbc_python_go_RPCGetRowsAffected", (PyCFunction) _wrap__goodbc_python_go_goodbc_python_go_RPCGetRowsAffected, METH_KEYWORDS|METH_VARARGS, "goodbc_python_go_RPCGetRowsAffected(sessionID, resultID)\n\ntype: sessionID: uint64_t\ntype: resultID: uint64_t" },
    {NULL, NULL, 0, NULL}
};
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef _goodbc_python_go_moduledef = {
    PyModuleDef_HEAD_INIT,
    "_goodbc_python_go",
    NULL,
    -1,
    _goodbc_python_go_functions,
};
#endif


#if PY_VERSION_HEX >= 0x03000000
    #define MOD_ERROR NULL
    #define MOD_INIT(name) PyObject* PyInit_##name(void)
    #define MOD_RETURN(val) val
#else
    #define MOD_ERROR
    #define MOD_INIT(name) void init##name(void)
    #define MOD_RETURN(val)
#endif
#if defined(__cplusplus)
extern "C"
#endif
#if defined(__GNUC__) && __GNUC__ >= 4
__attribute__ ((visibility("default")))
#endif


MOD_INIT(_goodbc_python_go)
{
    PyObject *m;
    #if PY_VERSION_HEX >= 0x03000000
    m = PyModule_Create(&_goodbc_python_go_moduledef);
    #else
    m = Py_InitModule3((char *) "_goodbc_python_go", _goodbc_python_go_functions, NULL);
    #endif
    if (m == NULL) {
        return MOD_ERROR;
    }
    return MOD_RETURN(m);
}
