PyDoc_STRVAR(sys_addaudithook__doc__,

"Adds a new audit hook callback.");

#define SYS_ADDAUDITHOOK_METHODDEF \

{"addaudithook", (PyCFunction)(void(*)(void))sys_addaudithook, METH_FASTCALL|METH_KEYWORDS, sys_addaudithook__doc__},

static PyObject *

sys_addaudithook_impl(PyObject *module, PyObject *hook);

static PyObject *

sys_addaudithook(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"hook", NULL};

static _PyArg_Parser _parser = {NULL, _keywords, "addaudithook", 0};

PyObject *argsbuf[1];

PyObject *hook;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

hook = args[0];

return_value = sys_addaudithook_impl(module, hook);

exit:

return return_value;

}

PyDoc_STRVAR(sys_displayhook__doc__,

"Print an object to sys.stdout and also save it in builtins._");

#define SYS_DISPLAYHOOK_METHODDEF \

{"displayhook", (PyCFunction)sys_displayhook, METH_O, sys_displayhook__doc__},

PyDoc_STRVAR(sys_excepthook__doc__,

"Handle an exception by displaying it with a traceback on sys.stderr.");

#define SYS_EXCEPTHOOK_METHODDEF \

{"excepthook", (PyCFunction)(void(*)(void))sys_excepthook, METH_FASTCALL, sys_excepthook__doc__},

static PyObject *

sys_excepthook_impl(PyObject *module, PyObject *exctype, PyObject *value,

PyObject *traceback);

static PyObject *

sys_excepthook(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *exctype;

PyObject *value;

PyObject *traceback;

if (!_PyArg_CheckPositional("excepthook", nargs, 3, 3)) {

goto exit;

}

exctype = args[0];

value = args[1];

traceback = args[2];

return_value = sys_excepthook_impl(module, exctype, value, traceback);

exit:

return return_value;

}

PyDoc_STRVAR(sys_exc_info__doc__,

"clause in the current stack frame or in an older stack frame.");

#define SYS_EXC_INFO_METHODDEF \

{"exc_info", (PyCFunction)sys_exc_info, METH_NOARGS, sys_exc_info__doc__},

static PyObject *

sys_exc_info_impl(PyObject *module);

static PyObject *

sys_exc_info(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_exc_info_impl(module);

}

PyDoc_STRVAR(sys_unraisablehook__doc__,

"* object: Object causing the exception, can be None.");

#define SYS_UNRAISABLEHOOK_METHODDEF \

{"unraisablehook", (PyCFunction)sys_unraisablehook, METH_O, sys_unraisablehook__doc__},

PyDoc_STRVAR(sys_exit__doc__,

"exit status will be one (i.e., failure).");

#define SYS_EXIT_METHODDEF \

{"exit", (PyCFunction)(void(*)(void))sys_exit, METH_FASTCALL, sys_exit__doc__},

static PyObject *

sys_exit_impl(PyObject *module, PyObject *status);

static PyObject *

sys_exit(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *status = Py_None;

if (!_PyArg_CheckPositional("exit", nargs, 0, 1)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

status = args[0];

skip_optional:

return_value = sys_exit_impl(module, status);

exit:

return return_value;

}

PyDoc_STRVAR(sys_getdefaultencoding__doc__,

"Return the current default encoding used by the Unicode implementation.");

#define SYS_GETDEFAULTENCODING_METHODDEF \

{"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, METH_NOARGS, sys_getdefaultencoding__doc__},

static PyObject *

sys_getdefaultencoding_impl(PyObject *module);

static PyObject *

sys_getdefaultencoding(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getdefaultencoding_impl(module);

}

PyDoc_STRVAR(sys_getfilesystemencoding__doc__,

"Return the encoding used to convert Unicode filenames to OS filenames.");

#define SYS_GETFILESYSTEMENCODING_METHODDEF \

{"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, METH_NOARGS, sys_getfilesystemencoding__doc__},

static PyObject *

sys_getfilesystemencoding_impl(PyObject *module);

static PyObject *

sys_getfilesystemencoding(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getfilesystemencoding_impl(module);

}

PyDoc_STRVAR(sys_getfilesystemencodeerrors__doc__,

"Return the error mode used Unicode to OS filename conversion.");

#define SYS_GETFILESYSTEMENCODEERRORS_METHODDEF \

{"getfilesystemencodeerrors", (PyCFunction)sys_getfilesystemencodeerrors, METH_NOARGS, sys_getfilesystemencodeerrors__doc__},

static PyObject *

sys_getfilesystemencodeerrors_impl(PyObject *module);

static PyObject *

sys_getfilesystemencodeerrors(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getfilesystemencodeerrors_impl(module);

}

PyDoc_STRVAR(sys_intern__doc__,

"the previously interned string object with the same value.");

#define SYS_INTERN_METHODDEF \

{"intern", (PyCFunction)sys_intern, METH_O, sys_intern__doc__},

static PyObject *

sys_intern_impl(PyObject *module, PyObject *s);

static PyObject *

sys_intern(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

PyObject *s;

if (!PyUnicode_Check(arg)) {

_PyArg_BadArgument("intern", "argument", "str", arg);

goto exit;

}

if (PyUnicode_READY(arg) == -1) {

goto exit;

}

s = arg;

return_value = sys_intern_impl(module, s);

exit:

return return_value;

}

PyDoc_STRVAR(sys_gettrace__doc__,

"See the debugger chapter in the library manual.");

#define SYS_GETTRACE_METHODDEF \

{"gettrace", (PyCFunction)sys_gettrace, METH_NOARGS, sys_gettrace__doc__},

static PyObject *

sys_gettrace_impl(PyObject *module);

static PyObject *

sys_gettrace(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_gettrace_impl(module);

}

PyDoc_STRVAR(sys_getprofile__doc__,

"See the profiler chapter in the library manual.");

#define SYS_GETPROFILE_METHODDEF \

{"getprofile", (PyCFunction)sys_getprofile, METH_NOARGS, sys_getprofile__doc__},

static PyObject *

sys_getprofile_impl(PyObject *module);

static PyObject *

sys_getprofile(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getprofile_impl(module);

}

PyDoc_STRVAR(sys_setcheckinterval__doc__,

"This also affects how often thread switches occur.");

#define SYS_SETCHECKINTERVAL_METHODDEF \

{"setcheckinterval", (PyCFunction)sys_setcheckinterval, METH_O, sys_setcheckinterval__doc__},

static PyObject *

sys_setcheckinterval_impl(PyObject *module, int n);

static PyObject *

sys_setcheckinterval(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

int n;

if (PyFloat_Check(arg)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

goto exit;

}

n = _PyLong_AsInt(arg);

if (n == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = sys_setcheckinterval_impl(module, n);

exit:

return return_value;

}

PyDoc_STRVAR(sys_getcheckinterval__doc__,

"Return the current check interval; see sys.setcheckinterval().");

#define SYS_GETCHECKINTERVAL_METHODDEF \

{"getcheckinterval", (PyCFunction)sys_getcheckinterval, METH_NOARGS, sys_getcheckinterval__doc__},

static PyObject *

sys_getcheckinterval_impl(PyObject *module);

static PyObject *

sys_getcheckinterval(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getcheckinterval_impl(module);

}

PyDoc_STRVAR(sys_setswitchinterval__doc__,

"A typical value is 0.005 (5 milliseconds).");

#define SYS_SETSWITCHINTERVAL_METHODDEF \

{"setswitchinterval", (PyCFunction)sys_setswitchinterval, METH_O, sys_setswitchinterval__doc__},

static PyObject *

sys_setswitchinterval_impl(PyObject *module, double interval);

static PyObject *

sys_setswitchinterval(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

double interval;

if (PyFloat_CheckExact(arg)) {

interval = PyFloat_AS_DOUBLE(arg);

}

else

{

interval = PyFloat_AsDouble(arg);

if (interval == -1.0 && PyErr_Occurred()) {

goto exit;

}

}

return_value = sys_setswitchinterval_impl(module, interval);

exit:

return return_value;

}

PyDoc_STRVAR(sys_getswitchinterval__doc__,

"Return the current thread switch interval; see sys.setswitchinterval().");

#define SYS_GETSWITCHINTERVAL_METHODDEF \

{"getswitchinterval", (PyCFunction)sys_getswitchinterval, METH_NOARGS, sys_getswitchinterval__doc__},

static double

sys_getswitchinterval_impl(PyObject *module);

static PyObject *

sys_getswitchinterval(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

double _return_value;

_return_value = sys_getswitchinterval_impl(module);

if ((_return_value == -1.0) && PyErr_Occurred()) {

goto exit;

}

return_value = PyFloat_FromDouble(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(sys_setrecursionlimit__doc__,

"dependent.");

#define SYS_SETRECURSIONLIMIT_METHODDEF \

{"setrecursionlimit", (PyCFunction)sys_setrecursionlimit, METH_O, sys_setrecursionlimit__doc__},

static PyObject *

sys_setrecursionlimit_impl(PyObject *module, int new_limit);

static PyObject *

sys_setrecursionlimit(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

int new_limit;

if (PyFloat_Check(arg)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

goto exit;

}

new_limit = _PyLong_AsInt(arg);

if (new_limit == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = sys_setrecursionlimit_impl(module, new_limit);

exit:

return return_value;

}

PyDoc_STRVAR(sys_set_coroutine_origin_tracking_depth__doc__,

"Set a depth of 0 to disable.");

#define SYS_SET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF \

{"set_coroutine_origin_tracking_depth", (PyCFunction)(void(*)(void))sys_set_coroutine_origin_tracking_depth, METH_FASTCALL|METH_KEYWORDS, sys_set_coroutine_origin_tracking_depth__doc__},

static PyObject *

sys_set_coroutine_origin_tracking_depth_impl(PyObject *module, int depth);

static PyObject *

sys_set_coroutine_origin_tracking_depth(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"depth", NULL};

static _PyArg_Parser _parser = {NULL, _keywords, "set_coroutine_origin_tracking_depth", 0};

PyObject *argsbuf[1];

int depth;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

if (PyFloat_Check(args[0])) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

goto exit;

}

depth = _PyLong_AsInt(args[0]);

if (depth == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = sys_set_coroutine_origin_tracking_depth_impl(module, depth);

exit:

return return_value;

}

PyDoc_STRVAR(sys_get_coroutine_origin_tracking_depth__doc__,

"Check status of origin tracking for coroutine objects in this thread.");

#define SYS_GET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF \

{"get_coroutine_origin_tracking_depth", (PyCFunction)sys_get_coroutine_origin_tracking_depth, METH_NOARGS, sys_get_coroutine_origin_tracking_depth__doc__},

static int

sys_get_coroutine_origin_tracking_depth_impl(PyObject *module);

static PyObject *

sys_get_coroutine_origin_tracking_depth(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

int _return_value;

_return_value = sys_get_coroutine_origin_tracking_depth_impl(module);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromLong((long)_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(sys_get_asyncgen_hooks__doc__,

"This returns a namedtuple of the form (firstiter, finalizer).");

#define SYS_GET_ASYNCGEN_HOOKS_METHODDEF \

{"get_asyncgen_hooks", (PyCFunction)sys_get_asyncgen_hooks, METH_NOARGS, sys_get_asyncgen_hooks__doc__},

static PyObject *

sys_get_asyncgen_hooks_impl(PyObject *module);

static PyObject *

sys_get_asyncgen_hooks(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_get_asyncgen_hooks_impl(module);

}

PyDoc_STRVAR(sys_getrecursionlimit__doc__,

"of the C stack and crashing Python.");

#define SYS_GETRECURSIONLIMIT_METHODDEF \

{"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, sys_getrecursionlimit__doc__},

static PyObject *

sys_getrecursionlimit_impl(PyObject *module);

static PyObject *

sys_getrecursionlimit(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getrecursionlimit_impl(module);

}

#if defined(MS_WINDOWS)

PyDoc_STRVAR(sys_getwindowsversion__doc__,

"intended for identifying the OS rather than feature detection.");

#define SYS_GETWINDOWSVERSION_METHODDEF \

{"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, sys_getwindowsversion__doc__},

static PyObject *

sys_getwindowsversion_impl(PyObject *module);

static PyObject *

sys_getwindowsversion(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getwindowsversion_impl(module);

}

#endif /* defined(MS_WINDOWS) */

#if defined(MS_WINDOWS)

PyDoc_STRVAR(sys__enablelegacywindowsfsencoding__doc__,

"environment variable before launching Python.");

#define SYS__ENABLELEGACYWINDOWSFSENCODING_METHODDEF \

{"_enablelegacywindowsfsencoding", (PyCFunction)sys__enablelegacywindowsfsencoding, METH_NOARGS, sys__enablelegacywindowsfsencoding__doc__},

static PyObject *

sys__enablelegacywindowsfsencoding_impl(PyObject *module);

static PyObject *

sys__enablelegacywindowsfsencoding(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys__enablelegacywindowsfsencoding_impl(module);

}

#endif /* defined(MS_WINDOWS) */

#if defined(HAVE_DLOPEN)

PyDoc_STRVAR(sys_setdlopenflags__doc__,

"os.RTLD_LAZY).");

#define SYS_SETDLOPENFLAGS_METHODDEF \

{"setdlopenflags", (PyCFunction)sys_setdlopenflags, METH_O, sys_setdlopenflags__doc__},

static PyObject *

sys_setdlopenflags_impl(PyObject *module, int new_val);

static PyObject *

sys_setdlopenflags(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

int new_val;

if (PyFloat_Check(arg)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

goto exit;

}

new_val = _PyLong_AsInt(arg);

if (new_val == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = sys_setdlopenflags_impl(module, new_val);

exit:

return return_value;

}

#endif /* defined(HAVE_DLOPEN) */

#if defined(HAVE_DLOPEN)

PyDoc_STRVAR(sys_getdlopenflags__doc__,

"The flag constants are defined in the os module.");

#define SYS_GETDLOPENFLAGS_METHODDEF \

{"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, sys_getdlopenflags__doc__},

static PyObject *

sys_getdlopenflags_impl(PyObject *module);

static PyObject *

sys_getdlopenflags(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getdlopenflags_impl(module);

}

#endif /* defined(HAVE_DLOPEN) */

#if defined(USE_MALLOPT)

PyDoc_STRVAR(sys_mdebug__doc__,

"\n");

#define SYS_MDEBUG_METHODDEF \

{"mdebug", (PyCFunction)sys_mdebug, METH_O, sys_mdebug__doc__},

static PyObject *

sys_mdebug_impl(PyObject *module, int flag);

static PyObject *

sys_mdebug(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

int flag;

if (PyFloat_Check(arg)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

goto exit;

}

flag = _PyLong_AsInt(arg);

if (flag == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = sys_mdebug_impl(module, flag);

exit:

return return_value;

}

#endif /* defined(USE_MALLOPT) */

PyDoc_STRVAR(sys_getrefcount__doc__,

"getrefcount().");

#define SYS_GETREFCOUNT_METHODDEF \

{"getrefcount", (PyCFunction)sys_getrefcount, METH_O, sys_getrefcount__doc__},

static Py_ssize_t

sys_getrefcount_impl(PyObject *module, PyObject *object);

static PyObject *

sys_getrefcount(PyObject *module, PyObject *object)

{

PyObject *return_value = NULL;

Py_ssize_t _return_value;

_return_value = sys_getrefcount_impl(module, object);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromSsize_t(_return_value);

exit:

return return_value;

}

#if defined(Py_REF_DEBUG)

PyDoc_STRVAR(sys_gettotalrefcount__doc__,

"\n");

#define SYS_GETTOTALREFCOUNT_METHODDEF \

{"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS, sys_gettotalrefcount__doc__},

static Py_ssize_t

sys_gettotalrefcount_impl(PyObject *module);

static PyObject *

sys_gettotalrefcount(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

Py_ssize_t _return_value;

_return_value = sys_gettotalrefcount_impl(module);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromSsize_t(_return_value);

exit:

return return_value;

}

#endif /* defined(Py_REF_DEBUG) */

PyDoc_STRVAR(sys_getallocatedblocks__doc__,

"Return the number of memory blocks currently allocated.");

#define SYS_GETALLOCATEDBLOCKS_METHODDEF \

{"getallocatedblocks", (PyCFunction)sys_getallocatedblocks, METH_NOARGS, sys_getallocatedblocks__doc__},

static Py_ssize_t

sys_getallocatedblocks_impl(PyObject *module);

static PyObject *

sys_getallocatedblocks(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

Py_ssize_t _return_value;

_return_value = sys_getallocatedblocks_impl(module);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromSsize_t(_return_value);

exit:

return return_value;

}

#if defined(COUNT_ALLOCS)

PyDoc_STRVAR(sys_getcounts__doc__,

"\n");

#define SYS_GETCOUNTS_METHODDEF \

{"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS, sys_getcounts__doc__},

static PyObject *

sys_getcounts_impl(PyObject *module);

static PyObject *

sys_getcounts(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_getcounts_impl(module);

}

#endif /* defined(COUNT_ALLOCS) */

PyDoc_STRVAR(sys__getframe__doc__,

"only.");

#define SYS__GETFRAME_METHODDEF \

{"_getframe", (PyCFunction)(void(*)(void))sys__getframe, METH_FASTCALL, sys__getframe__doc__},

static PyObject *

sys__getframe_impl(PyObject *module, int depth);

static PyObject *

sys__getframe(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

int depth = 0;

if (!_PyArg_CheckPositional("_getframe", nargs, 0, 1)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (PyFloat_Check(args[0])) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

goto exit;

}

depth = _PyLong_AsInt(args[0]);

if (depth == -1 && PyErr_Occurred()) {

goto exit;

}

skip_optional:

return_value = sys__getframe_impl(module, depth);

exit:

return return_value;

}

PyDoc_STRVAR(sys__current_frames__doc__,

"This function should be used for specialized purposes only.");

#define SYS__CURRENT_FRAMES_METHODDEF \

{"_current_frames", (PyCFunction)sys__current_frames, METH_NOARGS, sys__current_frames__doc__},

static PyObject *

sys__current_frames_impl(PyObject *module);

static PyObject *

sys__current_frames(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys__current_frames_impl(module);

}

PyDoc_STRVAR(sys_call_tracing__doc__,

"some other code.");

#define SYS_CALL_TRACING_METHODDEF \

{"call_tracing", (PyCFunction)(void(*)(void))sys_call_tracing, METH_FASTCALL, sys_call_tracing__doc__},

static PyObject *

sys_call_tracing_impl(PyObject *module, PyObject *func, PyObject *funcargs);

static PyObject *

sys_call_tracing(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *func;

PyObject *funcargs;

if (!_PyArg_CheckPositional("call_tracing", nargs, 2, 2)) {

goto exit;

}

func = args[0];

if (!PyTuple_Check(args[1])) {

_PyArg_BadArgument("call_tracing", "argument 2", "tuple", args[1]);

goto exit;

}

funcargs = args[1];

return_value = sys_call_tracing_impl(module, func, funcargs);

exit:

return return_value;

}

PyDoc_STRVAR(sys_callstats__doc__,

"10. Number of stack pops performed by call_function()");

#define SYS_CALLSTATS_METHODDEF \

{"callstats", (PyCFunction)sys_callstats, METH_NOARGS, sys_callstats__doc__},

static PyObject *

sys_callstats_impl(PyObject *module);

static PyObject *

sys_callstats(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys_callstats_impl(module);

}

PyDoc_STRVAR(sys__debugmallocstats__doc__,

"checks.");

#define SYS__DEBUGMALLOCSTATS_METHODDEF \

{"_debugmallocstats", (PyCFunction)sys__debugmallocstats, METH_NOARGS, sys__debugmallocstats__doc__},

static PyObject *

sys__debugmallocstats_impl(PyObject *module);

static PyObject *

sys__debugmallocstats(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return sys__debugmallocstats_impl(module);

}