#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()

PyDoc_STRVAR(sys_addaudithook__doc__,

"Adds a new audit hook callback.");

#define SYS_ADDAUDITHOOK_METHODDEF \

{"addaudithook", _PyCFunction_CAST(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;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(hook), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

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

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "addaudithook",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

PyObject *hook;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

hook = args[0];

return_value = sys_addaudithook_impl(module, hook);

exit:

return return_value;

}

PyDoc_STRVAR(sys_audit__doc__,

"Passes the event to any audit hooks that are attached.");

#define SYS_AUDIT_METHODDEF \

{"audit", _PyCFunction_CAST(sys_audit), METH_FASTCALL, sys_audit__doc__},

static PyObject *

sys_audit_impl(PyObject *module, const char *event, PyObject *args);

static PyObject *

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

{

PyObject *return_value = NULL;

const char *event;

PyObject *__clinic_args = NULL;

if (!_PyArg_CheckPositional("audit", nargs, 1, PY_SSIZE_T_MAX)) {

goto exit;

}

if (!PyUnicode_Check(args[0])) {

_PyArg_BadArgument("audit", "argument 1", "str", args[0]);

goto exit;

}

Py_ssize_t event_length;

event = PyUnicode_AsUTF8AndSize(args[0], &event_length);

if (event == NULL) {

goto exit;

}

if (strlen(event) != (size_t)event_length) {

PyErr_SetString(PyExc_ValueError, "embedded null character");

goto exit;

}

__clinic_args = PyTuple_FromArray(args + 1, nargs - 1);

if (__clinic_args == NULL) {

goto exit;

}

return_value = sys_audit_impl(module, event, __clinic_args);

exit:

/* Cleanup for args */

Py_XDECREF(__clinic_args);

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_CAST(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_exception__doc__,

"if no such exception exists.");

#define SYS_EXCEPTION_METHODDEF \

{"exception", (PyCFunction)sys_exception, METH_NOARGS, sys_exception__doc__},

static PyObject *

sys_exception_impl(PyObject *module);

static PyObject *

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

{

return sys_exception_impl(module);

}

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_CAST(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;

}

s = arg;

return_value = sys_intern_impl(module, s);

exit:

return return_value;

}

PyDoc_STRVAR(sys__is_interned__doc__,

"Return True if the given string is \"interned\".");

#define SYS__IS_INTERNED_METHODDEF \

{"_is_interned", (PyCFunction)sys__is_interned, METH_O, sys__is_interned__doc__},

static int

sys__is_interned_impl(PyObject *module, PyObject *string);

static PyObject *

sys__is_interned(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

PyObject *string;

int _return_value;

if (!PyUnicode_Check(arg)) {

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

goto exit;

}

string = arg;

_return_value = sys__is_interned_impl(module, string);

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

goto exit;

}

return_value = PyBool_FromLong((long)_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(sys__is_immortal__doc__,

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

#define SYS__IS_IMMORTAL_METHODDEF \

{"_is_immortal", (PyCFunction)sys__is_immortal, METH_O, sys__is_immortal__doc__},

static int

sys__is_immortal_impl(PyObject *module, PyObject *op);

static PyObject *

sys__is_immortal(PyObject *module, PyObject *op)

{

PyObject *return_value = NULL;

int _return_value;

_return_value = sys__is_immortal_impl(module, op);

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

goto exit;

}

return_value = PyBool_FromLong((long)_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(sys_settrace__doc__,

"in the library manual.");

#define SYS_SETTRACE_METHODDEF \

{"settrace", (PyCFunction)sys_settrace, METH_O, sys_settrace__doc__},

PyDoc_STRVAR(sys__settraceallthreads__doc__,

"in the library manual.");

#define SYS__SETTRACEALLTHREADS_METHODDEF \

{"_settraceallthreads", (PyCFunction)sys__settraceallthreads, METH_O, sys__settraceallthreads__doc__},

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_setprofile__doc__,

"chapter in the library manual.");

#define SYS_SETPROFILE_METHODDEF \

{"setprofile", (PyCFunction)sys_setprofile, METH_O, sys_setprofile__doc__},

PyDoc_STRVAR(sys__setprofileallthreads__doc__,

"chapter in the library manual.");

#define SYS__SETPROFILEALLTHREADS_METHODDEF \

{"_setprofileallthreads", (PyCFunction)sys__setprofileallthreads, METH_O, sys__setprofileallthreads__doc__},

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_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;

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_CAST(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;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(depth), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

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

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "set_coroutine_origin_tracking_depth",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

int depth;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

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(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;

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;

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_get_int_max_str_digits__doc__,

"Return the maximum string digits limit for non-binary int<->str conversions.");

#define SYS_GET_INT_MAX_STR_DIGITS_METHODDEF \

{"get_int_max_str_digits", (PyCFunction)sys_get_int_max_str_digits, METH_NOARGS, sys_get_int_max_str_digits__doc__},

static PyObject *

sys_get_int_max_str_digits_impl(PyObject *module);

static PyObject *

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

{

return sys_get_int_max_str_digits_impl(module);

}

PyDoc_STRVAR(sys_set_int_max_str_digits__doc__,

"Set the maximum string digits limit for non-binary int<->str conversions.");

#define SYS_SET_INT_MAX_STR_DIGITS_METHODDEF \

{"set_int_max_str_digits", _PyCFunction_CAST(sys_set_int_max_str_digits), METH_FASTCALL|METH_KEYWORDS, sys_set_int_max_str_digits__doc__},

static PyObject *

sys_set_int_max_str_digits_impl(PyObject *module, int maxdigits);

static PyObject *

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

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(maxdigits), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

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

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "set_int_max_str_digits",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

int maxdigits;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

maxdigits = PyLong_AsInt(args[0]);

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

goto exit;

}

return_value = sys_set_int_max_str_digits_impl(module, maxdigits);

exit:

return return_value;

}

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) */