publishFullContrib: true for ydb

<HIDDEN_URL>
commit_hash:c82a80ac4594723cebf2c7387dec9c60217f603e

10 files changed, 10483 insertions, 0 deletions

diff --git a/contrib/tools/python3/Modules/clinic/_curses_panel.c.h b/contrib/tools/python3/Modules/clinic/_curses_panel.c.h
new file mode 100644
index 00000000000..b45f28d40cd
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_curses_panel.c.h
@@ -0,0 +1,425 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_curses_panel_panel_bottom__doc__,
+"bottom($self, /)\n"
+"--\n"
+"\n"
+"Push the panel to the bottom of the stack.");
+
+#define _CURSES_PANEL_PANEL_BOTTOM_METHODDEF    \
+    {"bottom", _PyCFunction_CAST(_curses_panel_panel_bottom), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_bottom__doc__},
+
+static PyObject *
+_curses_panel_panel_bottom_impl(PyCursesPanelObject *self, PyTypeObject *cls);
+
+static PyObject *
+_curses_panel_panel_bottom(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "bottom() takes no arguments");
+        return NULL;
+    }
+    return _curses_panel_panel_bottom_impl(self, cls);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_hide__doc__,
+"hide($self, /)\n"
+"--\n"
+"\n"
+"Hide the panel.\n"
+"\n"
+"This does not delete the object, it just makes the window on screen invisible.");
+
+#define _CURSES_PANEL_PANEL_HIDE_METHODDEF    \
+    {"hide", _PyCFunction_CAST(_curses_panel_panel_hide), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_hide__doc__},
+
+static PyObject *
+_curses_panel_panel_hide_impl(PyCursesPanelObject *self, PyTypeObject *cls);
+
+static PyObject *
+_curses_panel_panel_hide(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "hide() takes no arguments");
+        return NULL;
+    }
+    return _curses_panel_panel_hide_impl(self, cls);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_show__doc__,
+"show($self, /)\n"
+"--\n"
+"\n"
+"Display the panel (which might have been hidden).");
+
+#define _CURSES_PANEL_PANEL_SHOW_METHODDEF    \
+    {"show", _PyCFunction_CAST(_curses_panel_panel_show), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_show__doc__},
+
+static PyObject *
+_curses_panel_panel_show_impl(PyCursesPanelObject *self, PyTypeObject *cls);
+
+static PyObject *
+_curses_panel_panel_show(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "show() takes no arguments");
+        return NULL;
+    }
+    return _curses_panel_panel_show_impl(self, cls);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_top__doc__,
+"top($self, /)\n"
+"--\n"
+"\n"
+"Push panel to the top of the stack.");
+
+#define _CURSES_PANEL_PANEL_TOP_METHODDEF    \
+    {"top", _PyCFunction_CAST(_curses_panel_panel_top), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_top__doc__},
+
+static PyObject *
+_curses_panel_panel_top_impl(PyCursesPanelObject *self, PyTypeObject *cls);
+
+static PyObject *
+_curses_panel_panel_top(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "top() takes no arguments");
+        return NULL;
+    }
+    return _curses_panel_panel_top_impl(self, cls);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_above__doc__,
+"above($self, /)\n"
+"--\n"
+"\n"
+"Return the panel above the current panel.");
+
+#define _CURSES_PANEL_PANEL_ABOVE_METHODDEF    \
+    {"above", (PyCFunction)_curses_panel_panel_above, METH_NOARGS, _curses_panel_panel_above__doc__},
+
+static PyObject *
+_curses_panel_panel_above_impl(PyCursesPanelObject *self);
+
+static PyObject *
+_curses_panel_panel_above(PyCursesPanelObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_panel_above_impl(self);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_below__doc__,
+"below($self, /)\n"
+"--\n"
+"\n"
+"Return the panel below the current panel.");
+
+#define _CURSES_PANEL_PANEL_BELOW_METHODDEF    \
+    {"below", (PyCFunction)_curses_panel_panel_below, METH_NOARGS, _curses_panel_panel_below__doc__},
+
+static PyObject *
+_curses_panel_panel_below_impl(PyCursesPanelObject *self);
+
+static PyObject *
+_curses_panel_panel_below(PyCursesPanelObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_panel_below_impl(self);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_hidden__doc__,
+"hidden($self, /)\n"
+"--\n"
+"\n"
+"Return True if the panel is hidden (not visible), False otherwise.");
+
+#define _CURSES_PANEL_PANEL_HIDDEN_METHODDEF    \
+    {"hidden", (PyCFunction)_curses_panel_panel_hidden, METH_NOARGS, _curses_panel_panel_hidden__doc__},
+
+static PyObject *
+_curses_panel_panel_hidden_impl(PyCursesPanelObject *self);
+
+static PyObject *
+_curses_panel_panel_hidden(PyCursesPanelObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_panel_hidden_impl(self);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_move__doc__,
+"move($self, y, x, /)\n"
+"--\n"
+"\n"
+"Move the panel to the screen coordinates (y, x).");
+
+#define _CURSES_PANEL_PANEL_MOVE_METHODDEF    \
+    {"move", _PyCFunction_CAST(_curses_panel_panel_move), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_move__doc__},
+
+static PyObject *
+_curses_panel_panel_move_impl(PyCursesPanelObject *self, PyTypeObject *cls,
+                              int y, int x);
+
+static PyObject *
+_curses_panel_panel_move(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", "", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "move",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    int y;
+    int x;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    y = _PyLong_AsInt(args[0]);
+    if (y == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    x = _PyLong_AsInt(args[1]);
+    if (x == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_panel_panel_move_impl(self, cls, y, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_panel_panel_window__doc__,
+"window($self, /)\n"
+"--\n"
+"\n"
+"Return the window object associated with the panel.");
+
+#define _CURSES_PANEL_PANEL_WINDOW_METHODDEF    \
+    {"window", (PyCFunction)_curses_panel_panel_window, METH_NOARGS, _curses_panel_panel_window__doc__},
+
+static PyObject *
+_curses_panel_panel_window_impl(PyCursesPanelObject *self);
+
+static PyObject *
+_curses_panel_panel_window(PyCursesPanelObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_panel_window_impl(self);
+}
+
+PyDoc_STRVAR(_curses_panel_panel_replace__doc__,
+"replace($self, win, /)\n"
+"--\n"
+"\n"
+"Change the window associated with the panel to the window win.");
+
+#define _CURSES_PANEL_PANEL_REPLACE_METHODDEF    \
+    {"replace", _PyCFunction_CAST(_curses_panel_panel_replace), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_replace__doc__},
+
+static PyObject *
+_curses_panel_panel_replace_impl(PyCursesPanelObject *self,
+                                 PyTypeObject *cls,
+                                 PyCursesWindowObject *win);
+
+static PyObject *
+_curses_panel_panel_replace(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "replace",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyCursesWindowObject *win;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!PyObject_TypeCheck(args[0], &PyCursesWindow_Type)) {
+        _PyArg_BadArgument("replace", "argument 1", (&PyCursesWindow_Type)->tp_name, args[0]);
+        goto exit;
+    }
+    win = (PyCursesWindowObject *)args[0];
+    return_value = _curses_panel_panel_replace_impl(self, cls, win);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_panel_panel_set_userptr__doc__,
+"set_userptr($self, obj, /)\n"
+"--\n"
+"\n"
+"Set the panel\'s user pointer to obj.");
+
+#define _CURSES_PANEL_PANEL_SET_USERPTR_METHODDEF    \
+    {"set_userptr", _PyCFunction_CAST(_curses_panel_panel_set_userptr), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_set_userptr__doc__},
+
+static PyObject *
+_curses_panel_panel_set_userptr_impl(PyCursesPanelObject *self,
+                                     PyTypeObject *cls, PyObject *obj);
+
+static PyObject *
+_curses_panel_panel_set_userptr(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "set_userptr",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject *obj;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    obj = args[0];
+    return_value = _curses_panel_panel_set_userptr_impl(self, cls, obj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_panel_panel_userptr__doc__,
+"userptr($self, /)\n"
+"--\n"
+"\n"
+"Return the user pointer for the panel.");
+
+#define _CURSES_PANEL_PANEL_USERPTR_METHODDEF    \
+    {"userptr", _PyCFunction_CAST(_curses_panel_panel_userptr), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _curses_panel_panel_userptr__doc__},
+
+static PyObject *
+_curses_panel_panel_userptr_impl(PyCursesPanelObject *self,
+                                 PyTypeObject *cls);
+
+static PyObject *
+_curses_panel_panel_userptr(PyCursesPanelObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "userptr() takes no arguments");
+        return NULL;
+    }
+    return _curses_panel_panel_userptr_impl(self, cls);
+}
+
+PyDoc_STRVAR(_curses_panel_bottom_panel__doc__,
+"bottom_panel($module, /)\n"
+"--\n"
+"\n"
+"Return the bottom panel in the panel stack.");
+
+#define _CURSES_PANEL_BOTTOM_PANEL_METHODDEF    \
+    {"bottom_panel", (PyCFunction)_curses_panel_bottom_panel, METH_NOARGS, _curses_panel_bottom_panel__doc__},
+
+static PyObject *
+_curses_panel_bottom_panel_impl(PyObject *module);
+
+static PyObject *
+_curses_panel_bottom_panel(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_bottom_panel_impl(module);
+}
+
+PyDoc_STRVAR(_curses_panel_new_panel__doc__,
+"new_panel($module, win, /)\n"
+"--\n"
+"\n"
+"Return a panel object, associating it with the given window win.");
+
+#define _CURSES_PANEL_NEW_PANEL_METHODDEF    \
+    {"new_panel", (PyCFunction)_curses_panel_new_panel, METH_O, _curses_panel_new_panel__doc__},
+
+static PyObject *
+_curses_panel_new_panel_impl(PyObject *module, PyCursesWindowObject *win);
+
+static PyObject *
+_curses_panel_new_panel(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    PyCursesWindowObject *win;
+
+    if (!PyObject_TypeCheck(arg, &PyCursesWindow_Type)) {
+        _PyArg_BadArgument("new_panel", "argument", (&PyCursesWindow_Type)->tp_name, arg);
+        goto exit;
+    }
+    win = (PyCursesWindowObject *)arg;
+    return_value = _curses_panel_new_panel_impl(module, win);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_panel_top_panel__doc__,
+"top_panel($module, /)\n"
+"--\n"
+"\n"
+"Return the top panel in the panel stack.");
+
+#define _CURSES_PANEL_TOP_PANEL_METHODDEF    \
+    {"top_panel", (PyCFunction)_curses_panel_top_panel, METH_NOARGS, _curses_panel_top_panel__doc__},
+
+static PyObject *
+_curses_panel_top_panel_impl(PyObject *module);
+
+static PyObject *
+_curses_panel_top_panel(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_top_panel_impl(module);
+}
+
+PyDoc_STRVAR(_curses_panel_update_panels__doc__,
+"update_panels($module, /)\n"
+"--\n"
+"\n"
+"Updates the virtual screen after changes in the panel stack.\n"
+"\n"
+"This does not call curses.doupdate(), so you\'ll have to do this yourself.");
+
+#define _CURSES_PANEL_UPDATE_PANELS_METHODDEF    \
+    {"update_panels", (PyCFunction)_curses_panel_update_panels, METH_NOARGS, _curses_panel_update_panels__doc__},
+
+static PyObject *
+_curses_panel_update_panels_impl(PyObject *module);
+
+static PyObject *
+_curses_panel_update_panels(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_panel_update_panels_impl(module);
+}
+/*[clinic end generated code: output=550ee3ad1ce9ec07 input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_cursesmodule.c.h b/contrib/tools/python3/Modules/clinic/_cursesmodule.c.h
new file mode 100644
index 00000000000..9d99d41af5d
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_cursesmodule.c.h
@@ -0,0 +1,4316 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_curses_window_addch__doc__,
+"addch([y, x,] ch, [attr=_curses.A_NORMAL])\n"
+"Paint the character.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"  ch\n"
+"    Character to add.\n"
+"  attr\n"
+"    Attributes for the character.\n"
+"\n"
+"Paint character ch at (y, x) with attributes attr,\n"
+"overwriting any character previously painted at that location.\n"
+"By default, the character position and attributes are the\n"
+"current settings for the window object.");
+
+#define _CURSES_WINDOW_ADDCH_METHODDEF    \
+    {"addch", (PyCFunction)_curses_window_addch, METH_VARARGS, _curses_window_addch__doc__},
+
+static PyObject *
+_curses_window_addch_impl(PyCursesWindowObject *self, int group_left_1,
+                          int y, int x, PyObject *ch, int group_right_1,
+                          long attr);
+
+static PyObject *
+_curses_window_addch(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *ch;
+    int group_right_1 = 0;
+    long attr = A_NORMAL;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O:addch", &ch)) {
+                goto exit;
+            }
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "Ol:addch", &ch, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "iiO:addch", &y, &x, &ch)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOl:addch", &y, &x, &ch, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.addch requires 1 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_addch_impl(self, group_left_1, y, x, ch, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_addstr__doc__,
+"addstr([y, x,] str, [attr])\n"
+"Paint the string.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"  str\n"
+"    String to add.\n"
+"  attr\n"
+"    Attributes for characters.\n"
+"\n"
+"Paint the string str at (y, x) with attributes attr,\n"
+"overwriting anything previously on the display.\n"
+"By default, the character position and attributes are the\n"
+"current settings for the window object.");
+
+#define _CURSES_WINDOW_ADDSTR_METHODDEF    \
+    {"addstr", (PyCFunction)_curses_window_addstr, METH_VARARGS, _curses_window_addstr__doc__},
+
+static PyObject *
+_curses_window_addstr_impl(PyCursesWindowObject *self, int group_left_1,
+                           int y, int x, PyObject *str, int group_right_1,
+                           long attr);
+
+static PyObject *
+_curses_window_addstr(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *str;
+    int group_right_1 = 0;
+    long attr = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O:addstr", &str)) {
+                goto exit;
+            }
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "Ol:addstr", &str, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "iiO:addstr", &y, &x, &str)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOl:addstr", &y, &x, &str, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.addstr requires 1 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_addstr_impl(self, group_left_1, y, x, str, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_addnstr__doc__,
+"addnstr([y, x,] str, n, [attr])\n"
+"Paint at most n characters of the string.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"  str\n"
+"    String to add.\n"
+"  n\n"
+"    Maximal number of characters.\n"
+"  attr\n"
+"    Attributes for characters.\n"
+"\n"
+"Paint at most n characters of the string str at (y, x) with\n"
+"attributes attr, overwriting anything previously on the display.\n"
+"By default, the character position and attributes are the\n"
+"current settings for the window object.");
+
+#define _CURSES_WINDOW_ADDNSTR_METHODDEF    \
+    {"addnstr", (PyCFunction)_curses_window_addnstr, METH_VARARGS, _curses_window_addnstr__doc__},
+
+static PyObject *
+_curses_window_addnstr_impl(PyCursesWindowObject *self, int group_left_1,
+                            int y, int x, PyObject *str, int n,
+                            int group_right_1, long attr);
+
+static PyObject *
+_curses_window_addnstr(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *str;
+    int n;
+    int group_right_1 = 0;
+    long attr = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "Oi:addnstr", &str, &n)) {
+                goto exit;
+            }
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "Oil:addnstr", &str, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOi:addnstr", &y, &x, &str, &n)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 5:
+            if (!PyArg_ParseTuple(args, "iiOil:addnstr", &y, &x, &str, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.addnstr requires 2 to 5 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_addnstr_impl(self, group_left_1, y, x, str, n, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_bkgd__doc__,
+"bkgd($self, ch, attr=_curses.A_NORMAL, /)\n"
+"--\n"
+"\n"
+"Set the background property of the window.\n"
+"\n"
+"  ch\n"
+"    Background character.\n"
+"  attr\n"
+"    Background attributes.");
+
+#define _CURSES_WINDOW_BKGD_METHODDEF    \
+    {"bkgd", _PyCFunction_CAST(_curses_window_bkgd), METH_FASTCALL, _curses_window_bkgd__doc__},
+
+static PyObject *
+_curses_window_bkgd_impl(PyCursesWindowObject *self, PyObject *ch, long attr);
+
+static PyObject *
+_curses_window_bkgd(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *ch;
+    long attr = A_NORMAL;
+
+    if (!_PyArg_CheckPositional("bkgd", nargs, 1, 2)) {
+        goto exit;
+    }
+    ch = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    attr = PyLong_AsLong(args[1]);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_window_bkgd_impl(self, ch, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_attroff__doc__,
+"attroff($self, attr, /)\n"
+"--\n"
+"\n"
+"Remove attribute attr from the \"background\" set.");
+
+#define _CURSES_WINDOW_ATTROFF_METHODDEF    \
+    {"attroff", (PyCFunction)_curses_window_attroff, METH_O, _curses_window_attroff__doc__},
+
+static PyObject *
+_curses_window_attroff_impl(PyCursesWindowObject *self, long attr);
+
+static PyObject *
+_curses_window_attroff(PyCursesWindowObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    long attr;
+
+    attr = PyLong_AsLong(arg);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_attroff_impl(self, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_attron__doc__,
+"attron($self, attr, /)\n"
+"--\n"
+"\n"
+"Add attribute attr from the \"background\" set.");
+
+#define _CURSES_WINDOW_ATTRON_METHODDEF    \
+    {"attron", (PyCFunction)_curses_window_attron, METH_O, _curses_window_attron__doc__},
+
+static PyObject *
+_curses_window_attron_impl(PyCursesWindowObject *self, long attr);
+
+static PyObject *
+_curses_window_attron(PyCursesWindowObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    long attr;
+
+    attr = PyLong_AsLong(arg);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_attron_impl(self, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_attrset__doc__,
+"attrset($self, attr, /)\n"
+"--\n"
+"\n"
+"Set the \"background\" set of attributes.");
+
+#define _CURSES_WINDOW_ATTRSET_METHODDEF    \
+    {"attrset", (PyCFunction)_curses_window_attrset, METH_O, _curses_window_attrset__doc__},
+
+static PyObject *
+_curses_window_attrset_impl(PyCursesWindowObject *self, long attr);
+
+static PyObject *
+_curses_window_attrset(PyCursesWindowObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    long attr;
+
+    attr = PyLong_AsLong(arg);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_attrset_impl(self, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_bkgdset__doc__,
+"bkgdset($self, ch, attr=_curses.A_NORMAL, /)\n"
+"--\n"
+"\n"
+"Set the window\'s background.\n"
+"\n"
+"  ch\n"
+"    Background character.\n"
+"  attr\n"
+"    Background attributes.");
+
+#define _CURSES_WINDOW_BKGDSET_METHODDEF    \
+    {"bkgdset", _PyCFunction_CAST(_curses_window_bkgdset), METH_FASTCALL, _curses_window_bkgdset__doc__},
+
+static PyObject *
+_curses_window_bkgdset_impl(PyCursesWindowObject *self, PyObject *ch,
+                            long attr);
+
+static PyObject *
+_curses_window_bkgdset(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *ch;
+    long attr = A_NORMAL;
+
+    if (!_PyArg_CheckPositional("bkgdset", nargs, 1, 2)) {
+        goto exit;
+    }
+    ch = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    attr = PyLong_AsLong(args[1]);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_window_bkgdset_impl(self, ch, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_border__doc__,
+"border($self, ls=_curses.ACS_VLINE, rs=_curses.ACS_VLINE,\n"
+"       ts=_curses.ACS_HLINE, bs=_curses.ACS_HLINE,\n"
+"       tl=_curses.ACS_ULCORNER, tr=_curses.ACS_URCORNER,\n"
+"       bl=_curses.ACS_LLCORNER, br=_curses.ACS_LRCORNER, /)\n"
+"--\n"
+"\n"
+"Draw a border around the edges of the window.\n"
+"\n"
+"  ls\n"
+"    Left side.\n"
+"  rs\n"
+"    Right side.\n"
+"  ts\n"
+"    Top side.\n"
+"  bs\n"
+"    Bottom side.\n"
+"  tl\n"
+"    Upper-left corner.\n"
+"  tr\n"
+"    Upper-right corner.\n"
+"  bl\n"
+"    Bottom-left corner.\n"
+"  br\n"
+"    Bottom-right corner.\n"
+"\n"
+"Each parameter specifies the character to use for a specific part of the\n"
+"border.  The characters can be specified as integers or as one-character\n"
+"strings.  A 0 value for any parameter will cause the default character to be\n"
+"used for that parameter.");
+
+#define _CURSES_WINDOW_BORDER_METHODDEF    \
+    {"border", _PyCFunction_CAST(_curses_window_border), METH_FASTCALL, _curses_window_border__doc__},
+
+static PyObject *
+_curses_window_border_impl(PyCursesWindowObject *self, PyObject *ls,
+                           PyObject *rs, PyObject *ts, PyObject *bs,
+                           PyObject *tl, PyObject *tr, PyObject *bl,
+                           PyObject *br);
+
+static PyObject *
+_curses_window_border(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *ls = NULL;
+    PyObject *rs = NULL;
+    PyObject *ts = NULL;
+    PyObject *bs = NULL;
+    PyObject *tl = NULL;
+    PyObject *tr = NULL;
+    PyObject *bl = NULL;
+    PyObject *br = NULL;
+
+    if (!_PyArg_CheckPositional("border", nargs, 0, 8)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    ls = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    rs = args[1];
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    ts = args[2];
+    if (nargs < 4) {
+        goto skip_optional;
+    }
+    bs = args[3];
+    if (nargs < 5) {
+        goto skip_optional;
+    }
+    tl = args[4];
+    if (nargs < 6) {
+        goto skip_optional;
+    }
+    tr = args[5];
+    if (nargs < 7) {
+        goto skip_optional;
+    }
+    bl = args[6];
+    if (nargs < 8) {
+        goto skip_optional;
+    }
+    br = args[7];
+skip_optional:
+    return_value = _curses_window_border_impl(self, ls, rs, ts, bs, tl, tr, bl, br);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_box__doc__,
+"box([verch=0, horch=0])\n"
+"Draw a border around the edges of the window.\n"
+"\n"
+"  verch\n"
+"    Left and right side.\n"
+"  horch\n"
+"    Top and bottom side.\n"
+"\n"
+"Similar to border(), but both ls and rs are verch and both ts and bs are\n"
+"horch.  The default corner characters are always used by this function.");
+
+#define _CURSES_WINDOW_BOX_METHODDEF    \
+    {"box", (PyCFunction)_curses_window_box, METH_VARARGS, _curses_window_box__doc__},
+
+static PyObject *
+_curses_window_box_impl(PyCursesWindowObject *self, int group_right_1,
+                        PyObject *verch, PyObject *horch);
+
+static PyObject *
+_curses_window_box(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    PyObject *verch = _PyLong_GetZero();
+    PyObject *horch = _PyLong_GetZero();
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "OO:box", &verch, &horch)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.box requires 0 to 2 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_box_impl(self, group_right_1, verch, horch);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_delch__doc__,
+"delch([y, x])\n"
+"Delete any character at (y, x).\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.");
+
+#define _CURSES_WINDOW_DELCH_METHODDEF    \
+    {"delch", (PyCFunction)_curses_window_delch, METH_VARARGS, _curses_window_delch__doc__},
+
+static PyObject *
+_curses_window_delch_impl(PyCursesWindowObject *self, int group_right_1,
+                          int y, int x);
+
+static PyObject *
+_curses_window_delch(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int y = 0;
+    int x = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:delch", &y, &x)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.delch requires 0 to 2 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_delch_impl(self, group_right_1, y, x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_derwin__doc__,
+"derwin([nlines=0, ncols=0,] begin_y, begin_x)\n"
+"Create a sub-window (window-relative coordinates).\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.\n"
+"  begin_y\n"
+"    Top side y-coordinate.\n"
+"  begin_x\n"
+"    Left side x-coordinate.\n"
+"\n"
+"derwin() is the same as calling subwin(), except that begin_y and begin_x\n"
+"are relative to the origin of the window, rather than relative to the entire\n"
+"screen.");
+
+#define _CURSES_WINDOW_DERWIN_METHODDEF    \
+    {"derwin", (PyCFunction)_curses_window_derwin, METH_VARARGS, _curses_window_derwin__doc__},
+
+static PyObject *
+_curses_window_derwin_impl(PyCursesWindowObject *self, int group_left_1,
+                           int nlines, int ncols, int begin_y, int begin_x);
+
+static PyObject *
+_curses_window_derwin(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int nlines = 0;
+    int ncols = 0;
+    int begin_y;
+    int begin_x;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:derwin", &begin_y, &begin_x)) {
+                goto exit;
+            }
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiii:derwin", &nlines, &ncols, &begin_y, &begin_x)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.derwin requires 2 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_derwin_impl(self, group_left_1, nlines, ncols, begin_y, begin_x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_echochar__doc__,
+"echochar($self, ch, attr=_curses.A_NORMAL, /)\n"
+"--\n"
+"\n"
+"Add character ch with attribute attr, and refresh.\n"
+"\n"
+"  ch\n"
+"    Character to add.\n"
+"  attr\n"
+"    Attributes for the character.");
+
+#define _CURSES_WINDOW_ECHOCHAR_METHODDEF    \
+    {"echochar", _PyCFunction_CAST(_curses_window_echochar), METH_FASTCALL, _curses_window_echochar__doc__},
+
+static PyObject *
+_curses_window_echochar_impl(PyCursesWindowObject *self, PyObject *ch,
+                             long attr);
+
+static PyObject *
+_curses_window_echochar(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *ch;
+    long attr = A_NORMAL;
+
+    if (!_PyArg_CheckPositional("echochar", nargs, 1, 2)) {
+        goto exit;
+    }
+    ch = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    attr = PyLong_AsLong(args[1]);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_window_echochar_impl(self, ch, attr);
+
+exit:
+    return return_value;
+}
+
+#if defined(NCURSES_MOUSE_VERSION)
+
+PyDoc_STRVAR(_curses_window_enclose__doc__,
+"enclose($self, y, x, /)\n"
+"--\n"
+"\n"
+"Return True if the screen-relative coordinates are enclosed by the window.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.");
+
+#define _CURSES_WINDOW_ENCLOSE_METHODDEF    \
+    {"enclose", _PyCFunction_CAST(_curses_window_enclose), METH_FASTCALL, _curses_window_enclose__doc__},
+
+static PyObject *
+_curses_window_enclose_impl(PyCursesWindowObject *self, int y, int x);
+
+static PyObject *
+_curses_window_enclose(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int y;
+    int x;
+
+    if (!_PyArg_CheckPositional("enclose", nargs, 2, 2)) {
+        goto exit;
+    }
+    y = _PyLong_AsInt(args[0]);
+    if (y == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    x = _PyLong_AsInt(args[1]);
+    if (x == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_enclose_impl(self, y, x);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(NCURSES_MOUSE_VERSION) */
+
+PyDoc_STRVAR(_curses_window_getbkgd__doc__,
+"getbkgd($self, /)\n"
+"--\n"
+"\n"
+"Return the window\'s current background character/attribute pair.");
+
+#define _CURSES_WINDOW_GETBKGD_METHODDEF    \
+    {"getbkgd", (PyCFunction)_curses_window_getbkgd, METH_NOARGS, _curses_window_getbkgd__doc__},
+
+static long
+_curses_window_getbkgd_impl(PyCursesWindowObject *self);
+
+static PyObject *
+_curses_window_getbkgd(PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+    long _return_value;
+
+    _return_value = _curses_window_getbkgd_impl(self);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromLong(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_getch__doc__,
+"getch([y, x])\n"
+"Get a character code from terminal keyboard.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"\n"
+"The integer returned does not have to be in ASCII range: function keys,\n"
+"keypad keys and so on return numbers higher than 256.  In no-delay mode, -1\n"
+"is returned if there is no input, else getch() waits until a key is pressed.");
+
+#define _CURSES_WINDOW_GETCH_METHODDEF    \
+    {"getch", (PyCFunction)_curses_window_getch, METH_VARARGS, _curses_window_getch__doc__},
+
+static int
+_curses_window_getch_impl(PyCursesWindowObject *self, int group_right_1,
+                          int y, int x);
+
+static PyObject *
+_curses_window_getch(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int y = 0;
+    int x = 0;
+    int _return_value;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:getch", &y, &x)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.getch requires 0 to 2 arguments");
+            goto exit;
+    }
+    _return_value = _curses_window_getch_impl(self, group_right_1, y, x);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromLong((long)_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_getkey__doc__,
+"getkey([y, x])\n"
+"Get a character (string) from terminal keyboard.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"\n"
+"Returning a string instead of an integer, as getch() does.  Function keys,\n"
+"keypad keys and other special keys return a multibyte string containing the\n"
+"key name.  In no-delay mode, an exception is raised if there is no input.");
+
+#define _CURSES_WINDOW_GETKEY_METHODDEF    \
+    {"getkey", (PyCFunction)_curses_window_getkey, METH_VARARGS, _curses_window_getkey__doc__},
+
+static PyObject *
+_curses_window_getkey_impl(PyCursesWindowObject *self, int group_right_1,
+                           int y, int x);
+
+static PyObject *
+_curses_window_getkey(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int y = 0;
+    int x = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:getkey", &y, &x)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.getkey requires 0 to 2 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_getkey_impl(self, group_right_1, y, x);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_NCURSESW)
+
+PyDoc_STRVAR(_curses_window_get_wch__doc__,
+"get_wch([y, x])\n"
+"Get a wide character from terminal keyboard.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"\n"
+"Return a character for most keys, or an integer for function keys,\n"
+"keypad keys, and other special keys.");
+
+#define _CURSES_WINDOW_GET_WCH_METHODDEF    \
+    {"get_wch", (PyCFunction)_curses_window_get_wch, METH_VARARGS, _curses_window_get_wch__doc__},
+
+static PyObject *
+_curses_window_get_wch_impl(PyCursesWindowObject *self, int group_right_1,
+                            int y, int x);
+
+static PyObject *
+_curses_window_get_wch(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int y = 0;
+    int x = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:get_wch", &y, &x)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.get_wch requires 0 to 2 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_get_wch_impl(self, group_right_1, y, x);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_NCURSESW) */
+
+PyDoc_STRVAR(_curses_window_hline__doc__,
+"hline([y, x,] ch, n, [attr=_curses.A_NORMAL])\n"
+"Display a horizontal line.\n"
+"\n"
+"  y\n"
+"    Starting Y-coordinate.\n"
+"  x\n"
+"    Starting X-coordinate.\n"
+"  ch\n"
+"    Character to draw.\n"
+"  n\n"
+"    Line length.\n"
+"  attr\n"
+"    Attributes for the characters.");
+
+#define _CURSES_WINDOW_HLINE_METHODDEF    \
+    {"hline", (PyCFunction)_curses_window_hline, METH_VARARGS, _curses_window_hline__doc__},
+
+static PyObject *
+_curses_window_hline_impl(PyCursesWindowObject *self, int group_left_1,
+                          int y, int x, PyObject *ch, int n,
+                          int group_right_1, long attr);
+
+static PyObject *
+_curses_window_hline(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *ch;
+    int n;
+    int group_right_1 = 0;
+    long attr = A_NORMAL;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "Oi:hline", &ch, &n)) {
+                goto exit;
+            }
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "Oil:hline", &ch, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOi:hline", &y, &x, &ch, &n)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 5:
+            if (!PyArg_ParseTuple(args, "iiOil:hline", &y, &x, &ch, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.hline requires 2 to 5 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_hline_impl(self, group_left_1, y, x, ch, n, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_insch__doc__,
+"insch([y, x,] ch, [attr=_curses.A_NORMAL])\n"
+"Insert a character before the current or specified position.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"  ch\n"
+"    Character to insert.\n"
+"  attr\n"
+"    Attributes for the character.\n"
+"\n"
+"All characters to the right of the cursor are shifted one position right, with\n"
+"the rightmost characters on the line being lost.");
+
+#define _CURSES_WINDOW_INSCH_METHODDEF    \
+    {"insch", (PyCFunction)_curses_window_insch, METH_VARARGS, _curses_window_insch__doc__},
+
+static PyObject *
+_curses_window_insch_impl(PyCursesWindowObject *self, int group_left_1,
+                          int y, int x, PyObject *ch, int group_right_1,
+                          long attr);
+
+static PyObject *
+_curses_window_insch(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *ch;
+    int group_right_1 = 0;
+    long attr = A_NORMAL;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O:insch", &ch)) {
+                goto exit;
+            }
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "Ol:insch", &ch, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "iiO:insch", &y, &x, &ch)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOl:insch", &y, &x, &ch, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.insch requires 1 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_insch_impl(self, group_left_1, y, x, ch, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_inch__doc__,
+"inch([y, x])\n"
+"Return the character at the given position in the window.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"\n"
+"The bottom 8 bits are the character proper, and upper bits are the attributes.");
+
+#define _CURSES_WINDOW_INCH_METHODDEF    \
+    {"inch", (PyCFunction)_curses_window_inch, METH_VARARGS, _curses_window_inch__doc__},
+
+static unsigned long
+_curses_window_inch_impl(PyCursesWindowObject *self, int group_right_1,
+                         int y, int x);
+
+static PyObject *
+_curses_window_inch(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int y = 0;
+    int x = 0;
+    unsigned long _return_value;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:inch", &y, &x)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.inch requires 0 to 2 arguments");
+            goto exit;
+    }
+    _return_value = _curses_window_inch_impl(self, group_right_1, y, x);
+    if ((_return_value == (unsigned long)-1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromUnsignedLong(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_insstr__doc__,
+"insstr([y, x,] str, [attr])\n"
+"Insert the string before the current or specified position.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"  str\n"
+"    String to insert.\n"
+"  attr\n"
+"    Attributes for characters.\n"
+"\n"
+"Insert a character string (as many characters as will fit on the line)\n"
+"before the character under the cursor.  All characters to the right of\n"
+"the cursor are shifted right, with the rightmost characters on the line\n"
+"being lost.  The cursor position does not change (after moving to y, x,\n"
+"if specified).");
+
+#define _CURSES_WINDOW_INSSTR_METHODDEF    \
+    {"insstr", (PyCFunction)_curses_window_insstr, METH_VARARGS, _curses_window_insstr__doc__},
+
+static PyObject *
+_curses_window_insstr_impl(PyCursesWindowObject *self, int group_left_1,
+                           int y, int x, PyObject *str, int group_right_1,
+                           long attr);
+
+static PyObject *
+_curses_window_insstr(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *str;
+    int group_right_1 = 0;
+    long attr = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O:insstr", &str)) {
+                goto exit;
+            }
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "Ol:insstr", &str, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "iiO:insstr", &y, &x, &str)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOl:insstr", &y, &x, &str, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.insstr requires 1 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_insstr_impl(self, group_left_1, y, x, str, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_insnstr__doc__,
+"insnstr([y, x,] str, n, [attr])\n"
+"Insert at most n characters of the string.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"  str\n"
+"    String to insert.\n"
+"  n\n"
+"    Maximal number of characters.\n"
+"  attr\n"
+"    Attributes for characters.\n"
+"\n"
+"Insert a character string (as many characters as will fit on the line)\n"
+"before the character under the cursor, up to n characters.  If n is zero\n"
+"or negative, the entire string is inserted.  All characters to the right\n"
+"of the cursor are shifted right, with the rightmost characters on the line\n"
+"being lost.  The cursor position does not change (after moving to y, x, if\n"
+"specified).");
+
+#define _CURSES_WINDOW_INSNSTR_METHODDEF    \
+    {"insnstr", (PyCFunction)_curses_window_insnstr, METH_VARARGS, _curses_window_insnstr__doc__},
+
+static PyObject *
+_curses_window_insnstr_impl(PyCursesWindowObject *self, int group_left_1,
+                            int y, int x, PyObject *str, int n,
+                            int group_right_1, long attr);
+
+static PyObject *
+_curses_window_insnstr(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *str;
+    int n;
+    int group_right_1 = 0;
+    long attr = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "Oi:insnstr", &str, &n)) {
+                goto exit;
+            }
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "Oil:insnstr", &str, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOi:insnstr", &y, &x, &str, &n)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 5:
+            if (!PyArg_ParseTuple(args, "iiOil:insnstr", &y, &x, &str, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.insnstr requires 2 to 5 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_insnstr_impl(self, group_left_1, y, x, str, n, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_is_linetouched__doc__,
+"is_linetouched($self, line, /)\n"
+"--\n"
+"\n"
+"Return True if the specified line was modified, otherwise return False.\n"
+"\n"
+"  line\n"
+"    Line number.\n"
+"\n"
+"Raise a curses.error exception if line is not valid for the given window.");
+
+#define _CURSES_WINDOW_IS_LINETOUCHED_METHODDEF    \
+    {"is_linetouched", (PyCFunction)_curses_window_is_linetouched, METH_O, _curses_window_is_linetouched__doc__},
+
+static PyObject *
+_curses_window_is_linetouched_impl(PyCursesWindowObject *self, int line);
+
+static PyObject *
+_curses_window_is_linetouched(PyCursesWindowObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int line;
+
+    line = _PyLong_AsInt(arg);
+    if (line == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_is_linetouched_impl(self, line);
+
+exit:
+    return return_value;
+}
+
+#if defined(py_is_pad)
+
+PyDoc_STRVAR(_curses_window_noutrefresh__doc__,
+"noutrefresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])\n"
+"Mark for refresh but wait.\n"
+"\n"
+"This function updates the data structure representing the desired state of the\n"
+"window, but does not force an update of the physical screen.  To accomplish\n"
+"that, call doupdate().");
+
+#define _CURSES_WINDOW_NOUTREFRESH_METHODDEF    \
+    {"noutrefresh", (PyCFunction)_curses_window_noutrefresh, METH_VARARGS, _curses_window_noutrefresh__doc__},
+
+static PyObject *
+_curses_window_noutrefresh_impl(PyCursesWindowObject *self,
+                                int group_right_1, int pminrow, int pmincol,
+                                int sminrow, int smincol, int smaxrow,
+                                int smaxcol);
+
+static PyObject *
+_curses_window_noutrefresh(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int pminrow = 0;
+    int pmincol = 0;
+    int sminrow = 0;
+    int smincol = 0;
+    int smaxrow = 0;
+    int smaxcol = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 6:
+            if (!PyArg_ParseTuple(args, "iiiiii:noutrefresh", &pminrow, &pmincol, &sminrow, &smincol, &smaxrow, &smaxcol)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.noutrefresh requires 0 to 6 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_noutrefresh_impl(self, group_right_1, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(py_is_pad) */
+
+#if !defined(py_is_pad)
+
+PyDoc_STRVAR(_curses_window_noutrefresh__doc__,
+"noutrefresh($self, /)\n"
+"--\n"
+"\n"
+"Mark for refresh but wait.\n"
+"\n"
+"This function updates the data structure representing the desired state of the\n"
+"window, but does not force an update of the physical screen.  To accomplish\n"
+"that, call doupdate().");
+
+#define _CURSES_WINDOW_NOUTREFRESH_METHODDEF    \
+    {"noutrefresh", (PyCFunction)_curses_window_noutrefresh, METH_NOARGS, _curses_window_noutrefresh__doc__},
+
+static PyObject *
+_curses_window_noutrefresh_impl(PyCursesWindowObject *self);
+
+static PyObject *
+_curses_window_noutrefresh(PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_window_noutrefresh_impl(self);
+}
+
+#endif /* !defined(py_is_pad) */
+
+PyDoc_STRVAR(_curses_window_overlay__doc__,
+"overlay(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])\n"
+"Overlay the window on top of destwin.\n"
+"\n"
+"The windows need not be the same size, only the overlapping region is copied.\n"
+"This copy is non-destructive, which means that the current background\n"
+"character does not overwrite the old contents of destwin.\n"
+"\n"
+"To get fine-grained control over the copied region, the second form of\n"
+"overlay() can be used.  sminrow and smincol are the upper-left coordinates\n"
+"of the source window, and the other variables mark a rectangle in the\n"
+"destination window.");
+
+#define _CURSES_WINDOW_OVERLAY_METHODDEF    \
+    {"overlay", (PyCFunction)_curses_window_overlay, METH_VARARGS, _curses_window_overlay__doc__},
+
+static PyObject *
+_curses_window_overlay_impl(PyCursesWindowObject *self,
+                            PyCursesWindowObject *destwin, int group_right_1,
+                            int sminrow, int smincol, int dminrow,
+                            int dmincol, int dmaxrow, int dmaxcol);
+
+static PyObject *
+_curses_window_overlay(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyCursesWindowObject *destwin;
+    int group_right_1 = 0;
+    int sminrow = 0;
+    int smincol = 0;
+    int dminrow = 0;
+    int dmincol = 0;
+    int dmaxrow = 0;
+    int dmaxcol = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O!:overlay", &PyCursesWindow_Type, &destwin)) {
+                goto exit;
+            }
+            break;
+        case 7:
+            if (!PyArg_ParseTuple(args, "O!iiiiii:overlay", &PyCursesWindow_Type, &destwin, &sminrow, &smincol, &dminrow, &dmincol, &dmaxrow, &dmaxcol)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.overlay requires 1 to 7 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_overlay_impl(self, destwin, group_right_1, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_overwrite__doc__,
+"overwrite(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow,\n"
+"          dmaxcol])\n"
+"Overwrite the window on top of destwin.\n"
+"\n"
+"The windows need not be the same size, in which case only the overlapping\n"
+"region is copied.  This copy is destructive, which means that the current\n"
+"background character overwrites the old contents of destwin.\n"
+"\n"
+"To get fine-grained control over the copied region, the second form of\n"
+"overwrite() can be used. sminrow and smincol are the upper-left coordinates\n"
+"of the source window, the other variables mark a rectangle in the destination\n"
+"window.");
+
+#define _CURSES_WINDOW_OVERWRITE_METHODDEF    \
+    {"overwrite", (PyCFunction)_curses_window_overwrite, METH_VARARGS, _curses_window_overwrite__doc__},
+
+static PyObject *
+_curses_window_overwrite_impl(PyCursesWindowObject *self,
+                              PyCursesWindowObject *destwin,
+                              int group_right_1, int sminrow, int smincol,
+                              int dminrow, int dmincol, int dmaxrow,
+                              int dmaxcol);
+
+static PyObject *
+_curses_window_overwrite(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyCursesWindowObject *destwin;
+    int group_right_1 = 0;
+    int sminrow = 0;
+    int smincol = 0;
+    int dminrow = 0;
+    int dmincol = 0;
+    int dmaxrow = 0;
+    int dmaxcol = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O!:overwrite", &PyCursesWindow_Type, &destwin)) {
+                goto exit;
+            }
+            break;
+        case 7:
+            if (!PyArg_ParseTuple(args, "O!iiiiii:overwrite", &PyCursesWindow_Type, &destwin, &sminrow, &smincol, &dminrow, &dmincol, &dmaxrow, &dmaxcol)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.overwrite requires 1 to 7 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_overwrite_impl(self, destwin, group_right_1, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_putwin__doc__,
+"putwin($self, file, /)\n"
+"--\n"
+"\n"
+"Write all data associated with the window into the provided file object.\n"
+"\n"
+"This information can be later retrieved using the getwin() function.");
+
+#define _CURSES_WINDOW_PUTWIN_METHODDEF    \
+    {"putwin", (PyCFunction)_curses_window_putwin, METH_O, _curses_window_putwin__doc__},
+
+PyDoc_STRVAR(_curses_window_redrawln__doc__,
+"redrawln($self, beg, num, /)\n"
+"--\n"
+"\n"
+"Mark the specified lines corrupted.\n"
+"\n"
+"  beg\n"
+"    Starting line number.\n"
+"  num\n"
+"    The number of lines.\n"
+"\n"
+"They should be completely redrawn on the next refresh() call.");
+
+#define _CURSES_WINDOW_REDRAWLN_METHODDEF    \
+    {"redrawln", _PyCFunction_CAST(_curses_window_redrawln), METH_FASTCALL, _curses_window_redrawln__doc__},
+
+static PyObject *
+_curses_window_redrawln_impl(PyCursesWindowObject *self, int beg, int num);
+
+static PyObject *
+_curses_window_redrawln(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int beg;
+    int num;
+
+    if (!_PyArg_CheckPositional("redrawln", nargs, 2, 2)) {
+        goto exit;
+    }
+    beg = _PyLong_AsInt(args[0]);
+    if (beg == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    num = _PyLong_AsInt(args[1]);
+    if (num == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_redrawln_impl(self, beg, num);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_refresh__doc__,
+"refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])\n"
+"Update the display immediately.\n"
+"\n"
+"Synchronize actual screen with previous drawing/deleting methods.\n"
+"The 6 optional arguments can only be specified when the window is a pad\n"
+"created with newpad().  The additional parameters are needed to indicate\n"
+"what part of the pad and screen are involved.  pminrow and pmincol specify\n"
+"the upper left-hand corner of the rectangle to be displayed in the pad.\n"
+"sminrow, smincol, smaxrow, and smaxcol specify the edges of the rectangle to\n"
+"be displayed on the screen.  The lower right-hand corner of the rectangle to\n"
+"be displayed in the pad is calculated from the screen coordinates, since the\n"
+"rectangles must be the same size.  Both rectangles must be entirely contained\n"
+"within their respective structures.  Negative values of pminrow, pmincol,\n"
+"sminrow, or smincol are treated as if they were zero.");
+
+#define _CURSES_WINDOW_REFRESH_METHODDEF    \
+    {"refresh", (PyCFunction)_curses_window_refresh, METH_VARARGS, _curses_window_refresh__doc__},
+
+static PyObject *
+_curses_window_refresh_impl(PyCursesWindowObject *self, int group_right_1,
+                            int pminrow, int pmincol, int sminrow,
+                            int smincol, int smaxrow, int smaxcol);
+
+static PyObject *
+_curses_window_refresh(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int pminrow = 0;
+    int pmincol = 0;
+    int sminrow = 0;
+    int smincol = 0;
+    int smaxrow = 0;
+    int smaxcol = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 6:
+            if (!PyArg_ParseTuple(args, "iiiiii:refresh", &pminrow, &pmincol, &sminrow, &smincol, &smaxrow, &smaxcol)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.refresh requires 0 to 6 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_refresh_impl(self, group_right_1, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_setscrreg__doc__,
+"setscrreg($self, top, bottom, /)\n"
+"--\n"
+"\n"
+"Define a software scrolling region.\n"
+"\n"
+"  top\n"
+"    First line number.\n"
+"  bottom\n"
+"    Last line number.\n"
+"\n"
+"All scrolling actions will take place in this region.");
+
+#define _CURSES_WINDOW_SETSCRREG_METHODDEF    \
+    {"setscrreg", _PyCFunction_CAST(_curses_window_setscrreg), METH_FASTCALL, _curses_window_setscrreg__doc__},
+
+static PyObject *
+_curses_window_setscrreg_impl(PyCursesWindowObject *self, int top,
+                              int bottom);
+
+static PyObject *
+_curses_window_setscrreg(PyCursesWindowObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int top;
+    int bottom;
+
+    if (!_PyArg_CheckPositional("setscrreg", nargs, 2, 2)) {
+        goto exit;
+    }
+    top = _PyLong_AsInt(args[0]);
+    if (top == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    bottom = _PyLong_AsInt(args[1]);
+    if (bottom == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_window_setscrreg_impl(self, top, bottom);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_subwin__doc__,
+"subwin([nlines=0, ncols=0,] begin_y, begin_x)\n"
+"Create a sub-window (screen-relative coordinates).\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.\n"
+"  begin_y\n"
+"    Top side y-coordinate.\n"
+"  begin_x\n"
+"    Left side x-coordinate.\n"
+"\n"
+"By default, the sub-window will extend from the specified position to the\n"
+"lower right corner of the window.");
+
+#define _CURSES_WINDOW_SUBWIN_METHODDEF    \
+    {"subwin", (PyCFunction)_curses_window_subwin, METH_VARARGS, _curses_window_subwin__doc__},
+
+static PyObject *
+_curses_window_subwin_impl(PyCursesWindowObject *self, int group_left_1,
+                           int nlines, int ncols, int begin_y, int begin_x);
+
+static PyObject *
+_curses_window_subwin(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int nlines = 0;
+    int ncols = 0;
+    int begin_y;
+    int begin_x;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:subwin", &begin_y, &begin_x)) {
+                goto exit;
+            }
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiii:subwin", &nlines, &ncols, &begin_y, &begin_x)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.subwin requires 2 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_subwin_impl(self, group_left_1, nlines, ncols, begin_y, begin_x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_scroll__doc__,
+"scroll([lines=1])\n"
+"Scroll the screen or scrolling region.\n"
+"\n"
+"  lines\n"
+"    Number of lines to scroll.\n"
+"\n"
+"Scroll upward if the argument is positive and downward if it is negative.");
+
+#define _CURSES_WINDOW_SCROLL_METHODDEF    \
+    {"scroll", (PyCFunction)_curses_window_scroll, METH_VARARGS, _curses_window_scroll__doc__},
+
+static PyObject *
+_curses_window_scroll_impl(PyCursesWindowObject *self, int group_right_1,
+                           int lines);
+
+static PyObject *
+_curses_window_scroll(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_right_1 = 0;
+    int lines = 1;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 0:
+            break;
+        case 1:
+            if (!PyArg_ParseTuple(args, "i:scroll", &lines)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.scroll requires 0 to 1 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_scroll_impl(self, group_right_1, lines);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_touchline__doc__,
+"touchline(start, count, [changed=True])\n"
+"Pretend count lines have been changed, starting with line start.\n"
+"\n"
+"If changed is supplied, it specifies whether the affected lines are marked\n"
+"as having been changed (changed=True) or unchanged (changed=False).");
+
+#define _CURSES_WINDOW_TOUCHLINE_METHODDEF    \
+    {"touchline", (PyCFunction)_curses_window_touchline, METH_VARARGS, _curses_window_touchline__doc__},
+
+static PyObject *
+_curses_window_touchline_impl(PyCursesWindowObject *self, int start,
+                              int count, int group_right_1, int changed);
+
+static PyObject *
+_curses_window_touchline(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int start;
+    int count;
+    int group_right_1 = 0;
+    int changed = 1;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:touchline", &start, &count)) {
+                goto exit;
+            }
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "iip:touchline", &start, &count, &changed)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.touchline requires 2 to 3 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_touchline_impl(self, start, count, group_right_1, changed);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_window_vline__doc__,
+"vline([y, x,] ch, n, [attr=_curses.A_NORMAL])\n"
+"Display a vertical line.\n"
+"\n"
+"  y\n"
+"    Starting Y-coordinate.\n"
+"  x\n"
+"    Starting X-coordinate.\n"
+"  ch\n"
+"    Character to draw.\n"
+"  n\n"
+"    Line length.\n"
+"  attr\n"
+"    Attributes for the character.");
+
+#define _CURSES_WINDOW_VLINE_METHODDEF    \
+    {"vline", (PyCFunction)_curses_window_vline, METH_VARARGS, _curses_window_vline__doc__},
+
+static PyObject *
+_curses_window_vline_impl(PyCursesWindowObject *self, int group_left_1,
+                          int y, int x, PyObject *ch, int n,
+                          int group_right_1, long attr);
+
+static PyObject *
+_curses_window_vline(PyCursesWindowObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int y = 0;
+    int x = 0;
+    PyObject *ch;
+    int n;
+    int group_right_1 = 0;
+    long attr = A_NORMAL;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "Oi:vline", &ch, &n)) {
+                goto exit;
+            }
+            break;
+        case 3:
+            if (!PyArg_ParseTuple(args, "Oil:vline", &ch, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiOi:vline", &y, &x, &ch, &n)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        case 5:
+            if (!PyArg_ParseTuple(args, "iiOil:vline", &y, &x, &ch, &n, &attr)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.window.vline requires 2 to 5 arguments");
+            goto exit;
+    }
+    return_value = _curses_window_vline_impl(self, group_left_1, y, x, ch, n, group_right_1, attr);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_CURSES_FILTER)
+
+PyDoc_STRVAR(_curses_filter__doc__,
+"filter($module, /)\n"
+"--\n"
+"\n");
+
+#define _CURSES_FILTER_METHODDEF    \
+    {"filter", (PyCFunction)_curses_filter, METH_NOARGS, _curses_filter__doc__},
+
+static PyObject *
+_curses_filter_impl(PyObject *module);
+
+static PyObject *
+_curses_filter(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_filter_impl(module);
+}
+
+#endif /* defined(HAVE_CURSES_FILTER) */
+
+PyDoc_STRVAR(_curses_baudrate__doc__,
+"baudrate($module, /)\n"
+"--\n"
+"\n"
+"Return the output speed of the terminal in bits per second.");
+
+#define _CURSES_BAUDRATE_METHODDEF    \
+    {"baudrate", (PyCFunction)_curses_baudrate, METH_NOARGS, _curses_baudrate__doc__},
+
+static PyObject *
+_curses_baudrate_impl(PyObject *module);
+
+static PyObject *
+_curses_baudrate(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_baudrate_impl(module);
+}
+
+PyDoc_STRVAR(_curses_beep__doc__,
+"beep($module, /)\n"
+"--\n"
+"\n"
+"Emit a short attention sound.");
+
+#define _CURSES_BEEP_METHODDEF    \
+    {"beep", (PyCFunction)_curses_beep, METH_NOARGS, _curses_beep__doc__},
+
+static PyObject *
+_curses_beep_impl(PyObject *module);
+
+static PyObject *
+_curses_beep(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_beep_impl(module);
+}
+
+PyDoc_STRVAR(_curses_can_change_color__doc__,
+"can_change_color($module, /)\n"
+"--\n"
+"\n"
+"Return True if the programmer can change the colors displayed by the terminal.");
+
+#define _CURSES_CAN_CHANGE_COLOR_METHODDEF    \
+    {"can_change_color", (PyCFunction)_curses_can_change_color, METH_NOARGS, _curses_can_change_color__doc__},
+
+static PyObject *
+_curses_can_change_color_impl(PyObject *module);
+
+static PyObject *
+_curses_can_change_color(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_can_change_color_impl(module);
+}
+
+PyDoc_STRVAR(_curses_cbreak__doc__,
+"cbreak($module, flag=True, /)\n"
+"--\n"
+"\n"
+"Enter cbreak mode.\n"
+"\n"
+"  flag\n"
+"    If false, the effect is the same as calling nocbreak().\n"
+"\n"
+"In cbreak mode (sometimes called \"rare\" mode) normal tty line buffering is\n"
+"turned off and characters are available to be read one by one.  However,\n"
+"unlike raw mode, special characters (interrupt, quit, suspend, and flow\n"
+"control) retain their effects on the tty driver and calling program.\n"
+"Calling first raw() then cbreak() leaves the terminal in cbreak mode.");
+
+#define _CURSES_CBREAK_METHODDEF    \
+    {"cbreak", _PyCFunction_CAST(_curses_cbreak), METH_FASTCALL, _curses_cbreak__doc__},
+
+static PyObject *
+_curses_cbreak_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_cbreak(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int flag = 1;
+
+    if (!_PyArg_CheckPositional("cbreak", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    flag = PyObject_IsTrue(args[0]);
+    if (flag < 0) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_cbreak_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_color_content__doc__,
+"color_content($module, color_number, /)\n"
+"--\n"
+"\n"
+"Return the red, green, and blue (RGB) components of the specified color.\n"
+"\n"
+"  color_number\n"
+"    The number of the color (0 - (COLORS-1)).\n"
+"\n"
+"A 3-tuple is returned, containing the R, G, B values for the given color,\n"
+"which will be between 0 (no component) and 1000 (maximum amount of component).");
+
+#define _CURSES_COLOR_CONTENT_METHODDEF    \
+    {"color_content", (PyCFunction)_curses_color_content, METH_O, _curses_color_content__doc__},
+
+static PyObject *
+_curses_color_content_impl(PyObject *module, int color_number);
+
+static PyObject *
+_curses_color_content(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int color_number;
+
+    if (!color_converter(arg, &color_number)) {
+        goto exit;
+    }
+    return_value = _curses_color_content_impl(module, color_number);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_color_pair__doc__,
+"color_pair($module, pair_number, /)\n"
+"--\n"
+"\n"
+"Return the attribute value for displaying text in the specified color.\n"
+"\n"
+"  pair_number\n"
+"    The number of the color pair.\n"
+"\n"
+"This attribute value can be combined with A_STANDOUT, A_REVERSE, and the\n"
+"other A_* attributes.  pair_number() is the counterpart to this function.");
+
+#define _CURSES_COLOR_PAIR_METHODDEF    \
+    {"color_pair", (PyCFunction)_curses_color_pair, METH_O, _curses_color_pair__doc__},
+
+static PyObject *
+_curses_color_pair_impl(PyObject *module, int pair_number);
+
+static PyObject *
+_curses_color_pair(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int pair_number;
+
+    pair_number = _PyLong_AsInt(arg);
+    if (pair_number == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_color_pair_impl(module, pair_number);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_curs_set__doc__,
+"curs_set($module, visibility, /)\n"
+"--\n"
+"\n"
+"Set the cursor state.\n"
+"\n"
+"  visibility\n"
+"    0 for invisible, 1 for normal visible, or 2 for very visible.\n"
+"\n"
+"If the terminal supports the visibility requested, the previous cursor\n"
+"state is returned; otherwise, an exception is raised.  On many terminals,\n"
+"the \"visible\" mode is an underline cursor and the \"very visible\" mode is\n"
+"a block cursor.");
+
+#define _CURSES_CURS_SET_METHODDEF    \
+    {"curs_set", (PyCFunction)_curses_curs_set, METH_O, _curses_curs_set__doc__},
+
+static PyObject *
+_curses_curs_set_impl(PyObject *module, int visibility);
+
+static PyObject *
+_curses_curs_set(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int visibility;
+
+    visibility = _PyLong_AsInt(arg);
+    if (visibility == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_curs_set_impl(module, visibility);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_def_prog_mode__doc__,
+"def_prog_mode($module, /)\n"
+"--\n"
+"\n"
+"Save the current terminal mode as the \"program\" mode.\n"
+"\n"
+"The \"program\" mode is the mode when the running program is using curses.\n"
+"\n"
+"Subsequent calls to reset_prog_mode() will restore this mode.");
+
+#define _CURSES_DEF_PROG_MODE_METHODDEF    \
+    {"def_prog_mode", (PyCFunction)_curses_def_prog_mode, METH_NOARGS, _curses_def_prog_mode__doc__},
+
+static PyObject *
+_curses_def_prog_mode_impl(PyObject *module);
+
+static PyObject *
+_curses_def_prog_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_def_prog_mode_impl(module);
+}
+
+PyDoc_STRVAR(_curses_def_shell_mode__doc__,
+"def_shell_mode($module, /)\n"
+"--\n"
+"\n"
+"Save the current terminal mode as the \"shell\" mode.\n"
+"\n"
+"The \"shell\" mode is the mode when the running program is not using curses.\n"
+"\n"
+"Subsequent calls to reset_shell_mode() will restore this mode.");
+
+#define _CURSES_DEF_SHELL_MODE_METHODDEF    \
+    {"def_shell_mode", (PyCFunction)_curses_def_shell_mode, METH_NOARGS, _curses_def_shell_mode__doc__},
+
+static PyObject *
+_curses_def_shell_mode_impl(PyObject *module);
+
+static PyObject *
+_curses_def_shell_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_def_shell_mode_impl(module);
+}
+
+PyDoc_STRVAR(_curses_delay_output__doc__,
+"delay_output($module, ms, /)\n"
+"--\n"
+"\n"
+"Insert a pause in output.\n"
+"\n"
+"  ms\n"
+"    Duration in milliseconds.");
+
+#define _CURSES_DELAY_OUTPUT_METHODDEF    \
+    {"delay_output", (PyCFunction)_curses_delay_output, METH_O, _curses_delay_output__doc__},
+
+static PyObject *
+_curses_delay_output_impl(PyObject *module, int ms);
+
+static PyObject *
+_curses_delay_output(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int ms;
+
+    ms = _PyLong_AsInt(arg);
+    if (ms == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_delay_output_impl(module, ms);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_doupdate__doc__,
+"doupdate($module, /)\n"
+"--\n"
+"\n"
+"Update the physical screen to match the virtual screen.");
+
+#define _CURSES_DOUPDATE_METHODDEF    \
+    {"doupdate", (PyCFunction)_curses_doupdate, METH_NOARGS, _curses_doupdate__doc__},
+
+static PyObject *
+_curses_doupdate_impl(PyObject *module);
+
+static PyObject *
+_curses_doupdate(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_doupdate_impl(module);
+}
+
+PyDoc_STRVAR(_curses_echo__doc__,
+"echo($module, flag=True, /)\n"
+"--\n"
+"\n"
+"Enter echo mode.\n"
+"\n"
+"  flag\n"
+"    If false, the effect is the same as calling noecho().\n"
+"\n"
+"In echo mode, each character input is echoed to the screen as it is entered.");
+
+#define _CURSES_ECHO_METHODDEF    \
+    {"echo", _PyCFunction_CAST(_curses_echo), METH_FASTCALL, _curses_echo__doc__},
+
+static PyObject *
+_curses_echo_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_echo(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int flag = 1;
+
+    if (!_PyArg_CheckPositional("echo", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    flag = PyObject_IsTrue(args[0]);
+    if (flag < 0) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_echo_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_endwin__doc__,
+"endwin($module, /)\n"
+"--\n"
+"\n"
+"De-initialize the library, and return terminal to normal status.");
+
+#define _CURSES_ENDWIN_METHODDEF    \
+    {"endwin", (PyCFunction)_curses_endwin, METH_NOARGS, _curses_endwin__doc__},
+
+static PyObject *
+_curses_endwin_impl(PyObject *module);
+
+static PyObject *
+_curses_endwin(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_endwin_impl(module);
+}
+
+PyDoc_STRVAR(_curses_erasechar__doc__,
+"erasechar($module, /)\n"
+"--\n"
+"\n"
+"Return the user\'s current erase character.");
+
+#define _CURSES_ERASECHAR_METHODDEF    \
+    {"erasechar", (PyCFunction)_curses_erasechar, METH_NOARGS, _curses_erasechar__doc__},
+
+static PyObject *
+_curses_erasechar_impl(PyObject *module);
+
+static PyObject *
+_curses_erasechar(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_erasechar_impl(module);
+}
+
+PyDoc_STRVAR(_curses_flash__doc__,
+"flash($module, /)\n"
+"--\n"
+"\n"
+"Flash the screen.\n"
+"\n"
+"That is, change it to reverse-video and then change it back in a short interval.");
+
+#define _CURSES_FLASH_METHODDEF    \
+    {"flash", (PyCFunction)_curses_flash, METH_NOARGS, _curses_flash__doc__},
+
+static PyObject *
+_curses_flash_impl(PyObject *module);
+
+static PyObject *
+_curses_flash(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_flash_impl(module);
+}
+
+PyDoc_STRVAR(_curses_flushinp__doc__,
+"flushinp($module, /)\n"
+"--\n"
+"\n"
+"Flush all input buffers.\n"
+"\n"
+"This throws away any typeahead that has been typed by the user and has not\n"
+"yet been processed by the program.");
+
+#define _CURSES_FLUSHINP_METHODDEF    \
+    {"flushinp", (PyCFunction)_curses_flushinp, METH_NOARGS, _curses_flushinp__doc__},
+
+static PyObject *
+_curses_flushinp_impl(PyObject *module);
+
+static PyObject *
+_curses_flushinp(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_flushinp_impl(module);
+}
+
+#if defined(getsyx)
+
+PyDoc_STRVAR(_curses_getsyx__doc__,
+"getsyx($module, /)\n"
+"--\n"
+"\n"
+"Return the current coordinates of the virtual screen cursor.\n"
+"\n"
+"Return a (y, x) tuple.  If leaveok is currently true, return (-1, -1).");
+
+#define _CURSES_GETSYX_METHODDEF    \
+    {"getsyx", (PyCFunction)_curses_getsyx, METH_NOARGS, _curses_getsyx__doc__},
+
+static PyObject *
+_curses_getsyx_impl(PyObject *module);
+
+static PyObject *
+_curses_getsyx(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_getsyx_impl(module);
+}
+
+#endif /* defined(getsyx) */
+
+#if defined(NCURSES_MOUSE_VERSION)
+
+PyDoc_STRVAR(_curses_getmouse__doc__,
+"getmouse($module, /)\n"
+"--\n"
+"\n"
+"Retrieve the queued mouse event.\n"
+"\n"
+"After getch() returns KEY_MOUSE to signal a mouse event, this function\n"
+"returns a 5-tuple (id, x, y, z, bstate).");
+
+#define _CURSES_GETMOUSE_METHODDEF    \
+    {"getmouse", (PyCFunction)_curses_getmouse, METH_NOARGS, _curses_getmouse__doc__},
+
+static PyObject *
+_curses_getmouse_impl(PyObject *module);
+
+static PyObject *
+_curses_getmouse(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_getmouse_impl(module);
+}
+
+#endif /* defined(NCURSES_MOUSE_VERSION) */
+
+#if defined(NCURSES_MOUSE_VERSION)
+
+PyDoc_STRVAR(_curses_ungetmouse__doc__,
+"ungetmouse($module, id, x, y, z, bstate, /)\n"
+"--\n"
+"\n"
+"Push a KEY_MOUSE event onto the input queue.\n"
+"\n"
+"The following getmouse() will return the given state data.");
+
+#define _CURSES_UNGETMOUSE_METHODDEF    \
+    {"ungetmouse", _PyCFunction_CAST(_curses_ungetmouse), METH_FASTCALL, _curses_ungetmouse__doc__},
+
+static PyObject *
+_curses_ungetmouse_impl(PyObject *module, short id, int x, int y, int z,
+                        unsigned long bstate);
+
+static PyObject *
+_curses_ungetmouse(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    short id;
+    int x;
+    int y;
+    int z;
+    unsigned long bstate;
+
+    if (!_PyArg_CheckPositional("ungetmouse", nargs, 5, 5)) {
+        goto exit;
+    }
+    {
+        long ival = PyLong_AsLong(args[0]);
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        else if (ival < SHRT_MIN) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "signed short integer is less than minimum");
+            goto exit;
+        }
+        else if (ival > SHRT_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "signed short integer is greater than maximum");
+            goto exit;
+        }
+        else {
+            id = (short) ival;
+        }
+    }
+    x = _PyLong_AsInt(args[1]);
+    if (x == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    y = _PyLong_AsInt(args[2]);
+    if (y == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    z = _PyLong_AsInt(args[3]);
+    if (z == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (!PyLong_Check(args[4])) {
+        _PyArg_BadArgument("ungetmouse", "argument 5", "int", args[4]);
+        goto exit;
+    }
+    bstate = PyLong_AsUnsignedLongMask(args[4]);
+    return_value = _curses_ungetmouse_impl(module, id, x, y, z, bstate);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(NCURSES_MOUSE_VERSION) */
+
+PyDoc_STRVAR(_curses_getwin__doc__,
+"getwin($module, file, /)\n"
+"--\n"
+"\n"
+"Read window related data stored in the file by an earlier putwin() call.\n"
+"\n"
+"The routine then creates and initializes a new window using that data,\n"
+"returning the new window object.");
+
+#define _CURSES_GETWIN_METHODDEF    \
+    {"getwin", (PyCFunction)_curses_getwin, METH_O, _curses_getwin__doc__},
+
+PyDoc_STRVAR(_curses_halfdelay__doc__,
+"halfdelay($module, tenths, /)\n"
+"--\n"
+"\n"
+"Enter half-delay mode.\n"
+"\n"
+"  tenths\n"
+"    Maximal blocking delay in tenths of seconds (1 - 255).\n"
+"\n"
+"Use nocbreak() to leave half-delay mode.");
+
+#define _CURSES_HALFDELAY_METHODDEF    \
+    {"halfdelay", (PyCFunction)_curses_halfdelay, METH_O, _curses_halfdelay__doc__},
+
+static PyObject *
+_curses_halfdelay_impl(PyObject *module, unsigned char tenths);
+
+static PyObject *
+_curses_halfdelay(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    unsigned char tenths;
+
+    {
+        long ival = PyLong_AsLong(arg);
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        else if (ival < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "unsigned byte integer is less than minimum");
+            goto exit;
+        }
+        else if (ival > UCHAR_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "unsigned byte integer is greater than maximum");
+            goto exit;
+        }
+        else {
+            tenths = (unsigned char) ival;
+        }
+    }
+    return_value = _curses_halfdelay_impl(module, tenths);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_has_colors__doc__,
+"has_colors($module, /)\n"
+"--\n"
+"\n"
+"Return True if the terminal can display colors; otherwise, return False.");
+
+#define _CURSES_HAS_COLORS_METHODDEF    \
+    {"has_colors", (PyCFunction)_curses_has_colors, METH_NOARGS, _curses_has_colors__doc__},
+
+static PyObject *
+_curses_has_colors_impl(PyObject *module);
+
+static PyObject *
+_curses_has_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_has_colors_impl(module);
+}
+
+PyDoc_STRVAR(_curses_has_ic__doc__,
+"has_ic($module, /)\n"
+"--\n"
+"\n"
+"Return True if the terminal has insert- and delete-character capabilities.");
+
+#define _CURSES_HAS_IC_METHODDEF    \
+    {"has_ic", (PyCFunction)_curses_has_ic, METH_NOARGS, _curses_has_ic__doc__},
+
+static PyObject *
+_curses_has_ic_impl(PyObject *module);
+
+static PyObject *
+_curses_has_ic(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_has_ic_impl(module);
+}
+
+PyDoc_STRVAR(_curses_has_il__doc__,
+"has_il($module, /)\n"
+"--\n"
+"\n"
+"Return True if the terminal has insert- and delete-line capabilities.");
+
+#define _CURSES_HAS_IL_METHODDEF    \
+    {"has_il", (PyCFunction)_curses_has_il, METH_NOARGS, _curses_has_il__doc__},
+
+static PyObject *
+_curses_has_il_impl(PyObject *module);
+
+static PyObject *
+_curses_has_il(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_has_il_impl(module);
+}
+
+#if defined(HAVE_CURSES_HAS_KEY)
+
+PyDoc_STRVAR(_curses_has_key__doc__,
+"has_key($module, key, /)\n"
+"--\n"
+"\n"
+"Return True if the current terminal type recognizes a key with that value.\n"
+"\n"
+"  key\n"
+"    Key number.");
+
+#define _CURSES_HAS_KEY_METHODDEF    \
+    {"has_key", (PyCFunction)_curses_has_key, METH_O, _curses_has_key__doc__},
+
+static PyObject *
+_curses_has_key_impl(PyObject *module, int key);
+
+static PyObject *
+_curses_has_key(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int key;
+
+    key = _PyLong_AsInt(arg);
+    if (key == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_has_key_impl(module, key);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CURSES_HAS_KEY) */
+
+PyDoc_STRVAR(_curses_init_color__doc__,
+"init_color($module, color_number, r, g, b, /)\n"
+"--\n"
+"\n"
+"Change the definition of a color.\n"
+"\n"
+"  color_number\n"
+"    The number of the color to be changed (0 - (COLORS-1)).\n"
+"  r\n"
+"    Red component (0 - 1000).\n"
+"  g\n"
+"    Green component (0 - 1000).\n"
+"  b\n"
+"    Blue component (0 - 1000).\n"
+"\n"
+"When init_color() is used, all occurrences of that color on the screen\n"
+"immediately change to the new definition.  This function is a no-op on\n"
+"most terminals; it is active only if can_change_color() returns true.");
+
+#define _CURSES_INIT_COLOR_METHODDEF    \
+    {"init_color", _PyCFunction_CAST(_curses_init_color), METH_FASTCALL, _curses_init_color__doc__},
+
+static PyObject *
+_curses_init_color_impl(PyObject *module, int color_number, short r, short g,
+                        short b);
+
+static PyObject *
+_curses_init_color(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int color_number;
+    short r;
+    short g;
+    short b;
+
+    if (!_PyArg_CheckPositional("init_color", nargs, 4, 4)) {
+        goto exit;
+    }
+    if (!color_converter(args[0], &color_number)) {
+        goto exit;
+    }
+    if (!component_converter(args[1], &r)) {
+        goto exit;
+    }
+    if (!component_converter(args[2], &g)) {
+        goto exit;
+    }
+    if (!component_converter(args[3], &b)) {
+        goto exit;
+    }
+    return_value = _curses_init_color_impl(module, color_number, r, g, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_init_pair__doc__,
+"init_pair($module, pair_number, fg, bg, /)\n"
+"--\n"
+"\n"
+"Change the definition of a color-pair.\n"
+"\n"
+"  pair_number\n"
+"    The number of the color-pair to be changed (1 - (COLOR_PAIRS-1)).\n"
+"  fg\n"
+"    Foreground color number (-1 - (COLORS-1)).\n"
+"  bg\n"
+"    Background color number (-1 - (COLORS-1)).\n"
+"\n"
+"If the color-pair was previously initialized, the screen is refreshed and\n"
+"all occurrences of that color-pair are changed to the new definition.");
+
+#define _CURSES_INIT_PAIR_METHODDEF    \
+    {"init_pair", _PyCFunction_CAST(_curses_init_pair), METH_FASTCALL, _curses_init_pair__doc__},
+
+static PyObject *
+_curses_init_pair_impl(PyObject *module, int pair_number, int fg, int bg);
+
+static PyObject *
+_curses_init_pair(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int pair_number;
+    int fg;
+    int bg;
+
+    if (!_PyArg_CheckPositional("init_pair", nargs, 3, 3)) {
+        goto exit;
+    }
+    if (!pair_converter(args[0], &pair_number)) {
+        goto exit;
+    }
+    if (!color_allow_default_converter(args[1], &fg)) {
+        goto exit;
+    }
+    if (!color_allow_default_converter(args[2], &bg)) {
+        goto exit;
+    }
+    return_value = _curses_init_pair_impl(module, pair_number, fg, bg);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_initscr__doc__,
+"initscr($module, /)\n"
+"--\n"
+"\n"
+"Initialize the library.\n"
+"\n"
+"Return a WindowObject which represents the whole screen.");
+
+#define _CURSES_INITSCR_METHODDEF    \
+    {"initscr", (PyCFunction)_curses_initscr, METH_NOARGS, _curses_initscr__doc__},
+
+static PyObject *
+_curses_initscr_impl(PyObject *module);
+
+static PyObject *
+_curses_initscr(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_initscr_impl(module);
+}
+
+PyDoc_STRVAR(_curses_setupterm__doc__,
+"setupterm($module, /, term=None, fd=-1)\n"
+"--\n"
+"\n"
+"Initialize the terminal.\n"
+"\n"
+"  term\n"
+"    Terminal name.\n"
+"    If omitted, the value of the TERM environment variable will be used.\n"
+"  fd\n"
+"    File descriptor to which any initialization sequences will be sent.\n"
+"    If not supplied, the file descriptor for sys.stdout will be used.");
+
+#define _CURSES_SETUPTERM_METHODDEF    \
+    {"setupterm", _PyCFunction_CAST(_curses_setupterm), METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
+
+static PyObject *
+_curses_setupterm_impl(PyObject *module, const char *term, int fd);
+
+static PyObject *
+_curses_setupterm(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(term), &_Py_ID(fd), },
+    };
+    #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[] = {"term", "fd", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "setupterm",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    const char *term = NULL;
+    int fd = -1;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        if (args[0] == Py_None) {
+            term = NULL;
+        }
+        else if (PyUnicode_Check(args[0])) {
+            Py_ssize_t term_length;
+            term = PyUnicode_AsUTF8AndSize(args[0], &term_length);
+            if (term == NULL) {
+                goto exit;
+            }
+            if (strlen(term) != (size_t)term_length) {
+                PyErr_SetString(PyExc_ValueError, "embedded null character");
+                goto exit;
+            }
+        }
+        else {
+            _PyArg_BadArgument("setupterm", "argument 'term'", "str or None", args[0]);
+            goto exit;
+        }
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    fd = _PyLong_AsInt(args[1]);
+    if (fd == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional_pos:
+    return_value = _curses_setupterm_impl(module, term, fd);
+
+exit:
+    return return_value;
+}
+
+#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
+
+PyDoc_STRVAR(_curses_get_escdelay__doc__,
+"get_escdelay($module, /)\n"
+"--\n"
+"\n"
+"Gets the curses ESCDELAY setting.\n"
+"\n"
+"Gets the number of milliseconds to wait after reading an escape character,\n"
+"to distinguish between an individual escape character entered on the\n"
+"keyboard from escape sequences sent by cursor and function keys.");
+
+#define _CURSES_GET_ESCDELAY_METHODDEF    \
+    {"get_escdelay", (PyCFunction)_curses_get_escdelay, METH_NOARGS, _curses_get_escdelay__doc__},
+
+static PyObject *
+_curses_get_escdelay_impl(PyObject *module);
+
+static PyObject *
+_curses_get_escdelay(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_get_escdelay_impl(module);
+}
+
+#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
+
+#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
+
+PyDoc_STRVAR(_curses_set_escdelay__doc__,
+"set_escdelay($module, ms, /)\n"
+"--\n"
+"\n"
+"Sets the curses ESCDELAY setting.\n"
+"\n"
+"  ms\n"
+"    length of the delay in milliseconds.\n"
+"\n"
+"Sets the number of milliseconds to wait after reading an escape character,\n"
+"to distinguish between an individual escape character entered on the\n"
+"keyboard from escape sequences sent by cursor and function keys.");
+
+#define _CURSES_SET_ESCDELAY_METHODDEF    \
+    {"set_escdelay", (PyCFunction)_curses_set_escdelay, METH_O, _curses_set_escdelay__doc__},
+
+static PyObject *
+_curses_set_escdelay_impl(PyObject *module, int ms);
+
+static PyObject *
+_curses_set_escdelay(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int ms;
+
+    ms = _PyLong_AsInt(arg);
+    if (ms == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_set_escdelay_impl(module, ms);
+
+exit:
+    return return_value;
+}
+
+#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
+
+#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
+
+PyDoc_STRVAR(_curses_get_tabsize__doc__,
+"get_tabsize($module, /)\n"
+"--\n"
+"\n"
+"Gets the curses TABSIZE setting.\n"
+"\n"
+"Gets the number of columns used by the curses library when converting a tab\n"
+"character to spaces as it adds the tab to a window.");
+
+#define _CURSES_GET_TABSIZE_METHODDEF    \
+    {"get_tabsize", (PyCFunction)_curses_get_tabsize, METH_NOARGS, _curses_get_tabsize__doc__},
+
+static PyObject *
+_curses_get_tabsize_impl(PyObject *module);
+
+static PyObject *
+_curses_get_tabsize(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_get_tabsize_impl(module);
+}
+
+#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
+
+#if (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102)
+
+PyDoc_STRVAR(_curses_set_tabsize__doc__,
+"set_tabsize($module, size, /)\n"
+"--\n"
+"\n"
+"Sets the curses TABSIZE setting.\n"
+"\n"
+"  size\n"
+"    rendered cell width of a tab character.\n"
+"\n"
+"Sets the number of columns used by the curses library when converting a tab\n"
+"character to spaces as it adds the tab to a window.");
+
+#define _CURSES_SET_TABSIZE_METHODDEF    \
+    {"set_tabsize", (PyCFunction)_curses_set_tabsize, METH_O, _curses_set_tabsize__doc__},
+
+static PyObject *
+_curses_set_tabsize_impl(PyObject *module, int size);
+
+static PyObject *
+_curses_set_tabsize(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int size;
+
+    size = _PyLong_AsInt(arg);
+    if (size == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_set_tabsize_impl(module, size);
+
+exit:
+    return return_value;
+}
+
+#endif /* (defined(NCURSES_EXT_FUNCS) && NCURSES_EXT_FUNCS >= 20081102) */
+
+PyDoc_STRVAR(_curses_intrflush__doc__,
+"intrflush($module, flag, /)\n"
+"--\n"
+"\n");
+
+#define _CURSES_INTRFLUSH_METHODDEF    \
+    {"intrflush", (PyCFunction)_curses_intrflush, METH_O, _curses_intrflush__doc__},
+
+static PyObject *
+_curses_intrflush_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_intrflush(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int flag;
+
+    flag = PyObject_IsTrue(arg);
+    if (flag < 0) {
+        goto exit;
+    }
+    return_value = _curses_intrflush_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_isendwin__doc__,
+"isendwin($module, /)\n"
+"--\n"
+"\n"
+"Return True if endwin() has been called.");
+
+#define _CURSES_ISENDWIN_METHODDEF    \
+    {"isendwin", (PyCFunction)_curses_isendwin, METH_NOARGS, _curses_isendwin__doc__},
+
+static PyObject *
+_curses_isendwin_impl(PyObject *module);
+
+static PyObject *
+_curses_isendwin(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_isendwin_impl(module);
+}
+
+#if defined(HAVE_CURSES_IS_TERM_RESIZED)
+
+PyDoc_STRVAR(_curses_is_term_resized__doc__,
+"is_term_resized($module, nlines, ncols, /)\n"
+"--\n"
+"\n"
+"Return True if resize_term() would modify the window structure, False otherwise.\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.");
+
+#define _CURSES_IS_TERM_RESIZED_METHODDEF    \
+    {"is_term_resized", _PyCFunction_CAST(_curses_is_term_resized), METH_FASTCALL, _curses_is_term_resized__doc__},
+
+static PyObject *
+_curses_is_term_resized_impl(PyObject *module, int nlines, int ncols);
+
+static PyObject *
+_curses_is_term_resized(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int nlines;
+    int ncols;
+
+    if (!_PyArg_CheckPositional("is_term_resized", nargs, 2, 2)) {
+        goto exit;
+    }
+    nlines = _PyLong_AsInt(args[0]);
+    if (nlines == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    ncols = _PyLong_AsInt(args[1]);
+    if (ncols == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_is_term_resized_impl(module, nlines, ncols);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CURSES_IS_TERM_RESIZED) */
+
+PyDoc_STRVAR(_curses_keyname__doc__,
+"keyname($module, key, /)\n"
+"--\n"
+"\n"
+"Return the name of specified key.\n"
+"\n"
+"  key\n"
+"    Key number.");
+
+#define _CURSES_KEYNAME_METHODDEF    \
+    {"keyname", (PyCFunction)_curses_keyname, METH_O, _curses_keyname__doc__},
+
+static PyObject *
+_curses_keyname_impl(PyObject *module, int key);
+
+static PyObject *
+_curses_keyname(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int key;
+
+    key = _PyLong_AsInt(arg);
+    if (key == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_keyname_impl(module, key);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_killchar__doc__,
+"killchar($module, /)\n"
+"--\n"
+"\n"
+"Return the user\'s current line kill character.");
+
+#define _CURSES_KILLCHAR_METHODDEF    \
+    {"killchar", (PyCFunction)_curses_killchar, METH_NOARGS, _curses_killchar__doc__},
+
+static PyObject *
+_curses_killchar_impl(PyObject *module);
+
+static PyObject *
+_curses_killchar(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_killchar_impl(module);
+}
+
+PyDoc_STRVAR(_curses_longname__doc__,
+"longname($module, /)\n"
+"--\n"
+"\n"
+"Return the terminfo long name field describing the current terminal.\n"
+"\n"
+"The maximum length of a verbose description is 128 characters.  It is defined\n"
+"only after the call to initscr().");
+
+#define _CURSES_LONGNAME_METHODDEF    \
+    {"longname", (PyCFunction)_curses_longname, METH_NOARGS, _curses_longname__doc__},
+
+static PyObject *
+_curses_longname_impl(PyObject *module);
+
+static PyObject *
+_curses_longname(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_longname_impl(module);
+}
+
+PyDoc_STRVAR(_curses_meta__doc__,
+"meta($module, yes, /)\n"
+"--\n"
+"\n"
+"Enable/disable meta keys.\n"
+"\n"
+"If yes is True, allow 8-bit characters to be input.  If yes is False,\n"
+"allow only 7-bit characters.");
+
+#define _CURSES_META_METHODDEF    \
+    {"meta", (PyCFunction)_curses_meta, METH_O, _curses_meta__doc__},
+
+static PyObject *
+_curses_meta_impl(PyObject *module, int yes);
+
+static PyObject *
+_curses_meta(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int yes;
+
+    yes = PyObject_IsTrue(arg);
+    if (yes < 0) {
+        goto exit;
+    }
+    return_value = _curses_meta_impl(module, yes);
+
+exit:
+    return return_value;
+}
+
+#if defined(NCURSES_MOUSE_VERSION)
+
+PyDoc_STRVAR(_curses_mouseinterval__doc__,
+"mouseinterval($module, interval, /)\n"
+"--\n"
+"\n"
+"Set and retrieve the maximum time between press and release in a click.\n"
+"\n"
+"  interval\n"
+"    Time in milliseconds.\n"
+"\n"
+"Set the maximum time that can elapse between press and release events in\n"
+"order for them to be recognized as a click, and return the previous interval\n"
+"value.");
+
+#define _CURSES_MOUSEINTERVAL_METHODDEF    \
+    {"mouseinterval", (PyCFunction)_curses_mouseinterval, METH_O, _curses_mouseinterval__doc__},
+
+static PyObject *
+_curses_mouseinterval_impl(PyObject *module, int interval);
+
+static PyObject *
+_curses_mouseinterval(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int interval;
+
+    interval = _PyLong_AsInt(arg);
+    if (interval == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_mouseinterval_impl(module, interval);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(NCURSES_MOUSE_VERSION) */
+
+#if defined(NCURSES_MOUSE_VERSION)
+
+PyDoc_STRVAR(_curses_mousemask__doc__,
+"mousemask($module, newmask, /)\n"
+"--\n"
+"\n"
+"Set the mouse events to be reported, and return a tuple (availmask, oldmask).\n"
+"\n"
+"Return a tuple (availmask, oldmask).  availmask indicates which of the\n"
+"specified mouse events can be reported; on complete failure it returns 0.\n"
+"oldmask is the previous value of the given window\'s mouse event mask.\n"
+"If this function is never called, no mouse events are ever reported.");
+
+#define _CURSES_MOUSEMASK_METHODDEF    \
+    {"mousemask", (PyCFunction)_curses_mousemask, METH_O, _curses_mousemask__doc__},
+
+static PyObject *
+_curses_mousemask_impl(PyObject *module, unsigned long newmask);
+
+static PyObject *
+_curses_mousemask(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    unsigned long newmask;
+
+    if (!PyLong_Check(arg)) {
+        _PyArg_BadArgument("mousemask", "argument", "int", arg);
+        goto exit;
+    }
+    newmask = PyLong_AsUnsignedLongMask(arg);
+    return_value = _curses_mousemask_impl(module, newmask);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(NCURSES_MOUSE_VERSION) */
+
+PyDoc_STRVAR(_curses_napms__doc__,
+"napms($module, ms, /)\n"
+"--\n"
+"\n"
+"Sleep for specified time.\n"
+"\n"
+"  ms\n"
+"    Duration in milliseconds.");
+
+#define _CURSES_NAPMS_METHODDEF    \
+    {"napms", (PyCFunction)_curses_napms, METH_O, _curses_napms__doc__},
+
+static PyObject *
+_curses_napms_impl(PyObject *module, int ms);
+
+static PyObject *
+_curses_napms(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int ms;
+
+    ms = _PyLong_AsInt(arg);
+    if (ms == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_napms_impl(module, ms);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_newpad__doc__,
+"newpad($module, nlines, ncols, /)\n"
+"--\n"
+"\n"
+"Create and return a pointer to a new pad data structure.\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.");
+
+#define _CURSES_NEWPAD_METHODDEF    \
+    {"newpad", _PyCFunction_CAST(_curses_newpad), METH_FASTCALL, _curses_newpad__doc__},
+
+static PyObject *
+_curses_newpad_impl(PyObject *module, int nlines, int ncols);
+
+static PyObject *
+_curses_newpad(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int nlines;
+    int ncols;
+
+    if (!_PyArg_CheckPositional("newpad", nargs, 2, 2)) {
+        goto exit;
+    }
+    nlines = _PyLong_AsInt(args[0]);
+    if (nlines == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    ncols = _PyLong_AsInt(args[1]);
+    if (ncols == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_newpad_impl(module, nlines, ncols);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_newwin__doc__,
+"newwin(nlines, ncols, [begin_y=0, begin_x=0])\n"
+"Return a new window.\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.\n"
+"  begin_y\n"
+"    Top side y-coordinate.\n"
+"  begin_x\n"
+"    Left side x-coordinate.\n"
+"\n"
+"By default, the window will extend from the specified position to the lower\n"
+"right corner of the screen.");
+
+#define _CURSES_NEWWIN_METHODDEF    \
+    {"newwin", (PyCFunction)_curses_newwin, METH_VARARGS, _curses_newwin__doc__},
+
+static PyObject *
+_curses_newwin_impl(PyObject *module, int nlines, int ncols,
+                    int group_right_1, int begin_y, int begin_x);
+
+static PyObject *
+_curses_newwin(PyObject *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int nlines;
+    int ncols;
+    int group_right_1 = 0;
+    int begin_y = 0;
+    int begin_x = 0;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 2:
+            if (!PyArg_ParseTuple(args, "ii:newwin", &nlines, &ncols)) {
+                goto exit;
+            }
+            break;
+        case 4:
+            if (!PyArg_ParseTuple(args, "iiii:newwin", &nlines, &ncols, &begin_y, &begin_x)) {
+                goto exit;
+            }
+            group_right_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "_curses.newwin requires 2 to 4 arguments");
+            goto exit;
+    }
+    return_value = _curses_newwin_impl(module, nlines, ncols, group_right_1, begin_y, begin_x);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_nl__doc__,
+"nl($module, flag=True, /)\n"
+"--\n"
+"\n"
+"Enter newline mode.\n"
+"\n"
+"  flag\n"
+"    If false, the effect is the same as calling nonl().\n"
+"\n"
+"This mode translates the return key into newline on input, and translates\n"
+"newline into return and line-feed on output.  Newline mode is initially on.");
+
+#define _CURSES_NL_METHODDEF    \
+    {"nl", _PyCFunction_CAST(_curses_nl), METH_FASTCALL, _curses_nl__doc__},
+
+static PyObject *
+_curses_nl_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_nl(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int flag = 1;
+
+    if (!_PyArg_CheckPositional("nl", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    flag = PyObject_IsTrue(args[0]);
+    if (flag < 0) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_nl_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_nocbreak__doc__,
+"nocbreak($module, /)\n"
+"--\n"
+"\n"
+"Leave cbreak mode.\n"
+"\n"
+"Return to normal \"cooked\" mode with line buffering.");
+
+#define _CURSES_NOCBREAK_METHODDEF    \
+    {"nocbreak", (PyCFunction)_curses_nocbreak, METH_NOARGS, _curses_nocbreak__doc__},
+
+static PyObject *
+_curses_nocbreak_impl(PyObject *module);
+
+static PyObject *
+_curses_nocbreak(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_nocbreak_impl(module);
+}
+
+PyDoc_STRVAR(_curses_noecho__doc__,
+"noecho($module, /)\n"
+"--\n"
+"\n"
+"Leave echo mode.\n"
+"\n"
+"Echoing of input characters is turned off.");
+
+#define _CURSES_NOECHO_METHODDEF    \
+    {"noecho", (PyCFunction)_curses_noecho, METH_NOARGS, _curses_noecho__doc__},
+
+static PyObject *
+_curses_noecho_impl(PyObject *module);
+
+static PyObject *
+_curses_noecho(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_noecho_impl(module);
+}
+
+PyDoc_STRVAR(_curses_nonl__doc__,
+"nonl($module, /)\n"
+"--\n"
+"\n"
+"Leave newline mode.\n"
+"\n"
+"Disable translation of return into newline on input, and disable low-level\n"
+"translation of newline into newline/return on output.");
+
+#define _CURSES_NONL_METHODDEF    \
+    {"nonl", (PyCFunction)_curses_nonl, METH_NOARGS, _curses_nonl__doc__},
+
+static PyObject *
+_curses_nonl_impl(PyObject *module);
+
+static PyObject *
+_curses_nonl(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_nonl_impl(module);
+}
+
+PyDoc_STRVAR(_curses_noqiflush__doc__,
+"noqiflush($module, /)\n"
+"--\n"
+"\n"
+"Disable queue flushing.\n"
+"\n"
+"When queue flushing is disabled, normal flush of input and output queues\n"
+"associated with the INTR, QUIT and SUSP characters will not be done.");
+
+#define _CURSES_NOQIFLUSH_METHODDEF    \
+    {"noqiflush", (PyCFunction)_curses_noqiflush, METH_NOARGS, _curses_noqiflush__doc__},
+
+static PyObject *
+_curses_noqiflush_impl(PyObject *module);
+
+static PyObject *
+_curses_noqiflush(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_noqiflush_impl(module);
+}
+
+PyDoc_STRVAR(_curses_noraw__doc__,
+"noraw($module, /)\n"
+"--\n"
+"\n"
+"Leave raw mode.\n"
+"\n"
+"Return to normal \"cooked\" mode with line buffering.");
+
+#define _CURSES_NORAW_METHODDEF    \
+    {"noraw", (PyCFunction)_curses_noraw, METH_NOARGS, _curses_noraw__doc__},
+
+static PyObject *
+_curses_noraw_impl(PyObject *module);
+
+static PyObject *
+_curses_noraw(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_noraw_impl(module);
+}
+
+PyDoc_STRVAR(_curses_pair_content__doc__,
+"pair_content($module, pair_number, /)\n"
+"--\n"
+"\n"
+"Return a tuple (fg, bg) containing the colors for the requested color pair.\n"
+"\n"
+"  pair_number\n"
+"    The number of the color pair (0 - (COLOR_PAIRS-1)).");
+
+#define _CURSES_PAIR_CONTENT_METHODDEF    \
+    {"pair_content", (PyCFunction)_curses_pair_content, METH_O, _curses_pair_content__doc__},
+
+static PyObject *
+_curses_pair_content_impl(PyObject *module, int pair_number);
+
+static PyObject *
+_curses_pair_content(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int pair_number;
+
+    if (!pair_converter(arg, &pair_number)) {
+        goto exit;
+    }
+    return_value = _curses_pair_content_impl(module, pair_number);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_pair_number__doc__,
+"pair_number($module, attr, /)\n"
+"--\n"
+"\n"
+"Return the number of the color-pair set by the specified attribute value.\n"
+"\n"
+"color_pair() is the counterpart to this function.");
+
+#define _CURSES_PAIR_NUMBER_METHODDEF    \
+    {"pair_number", (PyCFunction)_curses_pair_number, METH_O, _curses_pair_number__doc__},
+
+static PyObject *
+_curses_pair_number_impl(PyObject *module, int attr);
+
+static PyObject *
+_curses_pair_number(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int attr;
+
+    attr = _PyLong_AsInt(arg);
+    if (attr == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_pair_number_impl(module, attr);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_putp__doc__,
+"putp($module, string, /)\n"
+"--\n"
+"\n"
+"Emit the value of a specified terminfo capability for the current terminal.\n"
+"\n"
+"Note that the output of putp() always goes to standard output.");
+
+#define _CURSES_PUTP_METHODDEF    \
+    {"putp", (PyCFunction)_curses_putp, METH_O, _curses_putp__doc__},
+
+static PyObject *
+_curses_putp_impl(PyObject *module, const char *string);
+
+static PyObject *
+_curses_putp(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *string;
+
+    if (!PyArg_Parse(arg, "y:putp", &string)) {
+        goto exit;
+    }
+    return_value = _curses_putp_impl(module, string);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_qiflush__doc__,
+"qiflush($module, flag=True, /)\n"
+"--\n"
+"\n"
+"Enable queue flushing.\n"
+"\n"
+"  flag\n"
+"    If false, the effect is the same as calling noqiflush().\n"
+"\n"
+"If queue flushing is enabled, all output in the display driver queue\n"
+"will be flushed when the INTR, QUIT and SUSP characters are read.");
+
+#define _CURSES_QIFLUSH_METHODDEF    \
+    {"qiflush", _PyCFunction_CAST(_curses_qiflush), METH_FASTCALL, _curses_qiflush__doc__},
+
+static PyObject *
+_curses_qiflush_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_qiflush(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int flag = 1;
+
+    if (!_PyArg_CheckPositional("qiflush", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    flag = PyObject_IsTrue(args[0]);
+    if (flag < 0) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_qiflush_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+#if (defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM))
+
+PyDoc_STRVAR(_curses_update_lines_cols__doc__,
+"update_lines_cols($module, /)\n"
+"--\n"
+"\n");
+
+#define _CURSES_UPDATE_LINES_COLS_METHODDEF    \
+    {"update_lines_cols", (PyCFunction)_curses_update_lines_cols, METH_NOARGS, _curses_update_lines_cols__doc__},
+
+static PyObject *
+_curses_update_lines_cols_impl(PyObject *module);
+
+static PyObject *
+_curses_update_lines_cols(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_update_lines_cols_impl(module);
+}
+
+#endif /* (defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM)) */
+
+PyDoc_STRVAR(_curses_raw__doc__,
+"raw($module, flag=True, /)\n"
+"--\n"
+"\n"
+"Enter raw mode.\n"
+"\n"
+"  flag\n"
+"    If false, the effect is the same as calling noraw().\n"
+"\n"
+"In raw mode, normal line buffering and processing of interrupt, quit,\n"
+"suspend, and flow control keys are turned off; characters are presented to\n"
+"curses input functions one by one.");
+
+#define _CURSES_RAW_METHODDEF    \
+    {"raw", _PyCFunction_CAST(_curses_raw), METH_FASTCALL, _curses_raw__doc__},
+
+static PyObject *
+_curses_raw_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_raw(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int flag = 1;
+
+    if (!_PyArg_CheckPositional("raw", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    flag = PyObject_IsTrue(args[0]);
+    if (flag < 0) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _curses_raw_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_reset_prog_mode__doc__,
+"reset_prog_mode($module, /)\n"
+"--\n"
+"\n"
+"Restore the terminal to \"program\" mode, as previously saved by def_prog_mode().");
+
+#define _CURSES_RESET_PROG_MODE_METHODDEF    \
+    {"reset_prog_mode", (PyCFunction)_curses_reset_prog_mode, METH_NOARGS, _curses_reset_prog_mode__doc__},
+
+static PyObject *
+_curses_reset_prog_mode_impl(PyObject *module);
+
+static PyObject *
+_curses_reset_prog_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_reset_prog_mode_impl(module);
+}
+
+PyDoc_STRVAR(_curses_reset_shell_mode__doc__,
+"reset_shell_mode($module, /)\n"
+"--\n"
+"\n"
+"Restore the terminal to \"shell\" mode, as previously saved by def_shell_mode().");
+
+#define _CURSES_RESET_SHELL_MODE_METHODDEF    \
+    {"reset_shell_mode", (PyCFunction)_curses_reset_shell_mode, METH_NOARGS, _curses_reset_shell_mode__doc__},
+
+static PyObject *
+_curses_reset_shell_mode_impl(PyObject *module);
+
+static PyObject *
+_curses_reset_shell_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_reset_shell_mode_impl(module);
+}
+
+PyDoc_STRVAR(_curses_resetty__doc__,
+"resetty($module, /)\n"
+"--\n"
+"\n"
+"Restore terminal mode.");
+
+#define _CURSES_RESETTY_METHODDEF    \
+    {"resetty", (PyCFunction)_curses_resetty, METH_NOARGS, _curses_resetty__doc__},
+
+static PyObject *
+_curses_resetty_impl(PyObject *module);
+
+static PyObject *
+_curses_resetty(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_resetty_impl(module);
+}
+
+#if defined(HAVE_CURSES_RESIZETERM)
+
+PyDoc_STRVAR(_curses_resizeterm__doc__,
+"resizeterm($module, nlines, ncols, /)\n"
+"--\n"
+"\n"
+"Resize the standard and current windows to the specified dimensions.\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.\n"
+"\n"
+"Adjusts other bookkeeping data used by the curses library that record the\n"
+"window dimensions (in particular the SIGWINCH handler).");
+
+#define _CURSES_RESIZETERM_METHODDEF    \
+    {"resizeterm", _PyCFunction_CAST(_curses_resizeterm), METH_FASTCALL, _curses_resizeterm__doc__},
+
+static PyObject *
+_curses_resizeterm_impl(PyObject *module, int nlines, int ncols);
+
+static PyObject *
+_curses_resizeterm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int nlines;
+    int ncols;
+
+    if (!_PyArg_CheckPositional("resizeterm", nargs, 2, 2)) {
+        goto exit;
+    }
+    nlines = _PyLong_AsInt(args[0]);
+    if (nlines == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    ncols = _PyLong_AsInt(args[1]);
+    if (ncols == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_resizeterm_impl(module, nlines, ncols);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CURSES_RESIZETERM) */
+
+#if defined(HAVE_CURSES_RESIZE_TERM)
+
+PyDoc_STRVAR(_curses_resize_term__doc__,
+"resize_term($module, nlines, ncols, /)\n"
+"--\n"
+"\n"
+"Backend function used by resizeterm(), performing most of the work.\n"
+"\n"
+"  nlines\n"
+"    Height.\n"
+"  ncols\n"
+"    Width.\n"
+"\n"
+"When resizing the windows, resize_term() blank-fills the areas that are\n"
+"extended.  The calling application should fill in these areas with appropriate\n"
+"data.  The resize_term() function attempts to resize all windows.  However,\n"
+"due to the calling convention of pads, it is not possible to resize these\n"
+"without additional interaction with the application.");
+
+#define _CURSES_RESIZE_TERM_METHODDEF    \
+    {"resize_term", _PyCFunction_CAST(_curses_resize_term), METH_FASTCALL, _curses_resize_term__doc__},
+
+static PyObject *
+_curses_resize_term_impl(PyObject *module, int nlines, int ncols);
+
+static PyObject *
+_curses_resize_term(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int nlines;
+    int ncols;
+
+    if (!_PyArg_CheckPositional("resize_term", nargs, 2, 2)) {
+        goto exit;
+    }
+    nlines = _PyLong_AsInt(args[0]);
+    if (nlines == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    ncols = _PyLong_AsInt(args[1]);
+    if (ncols == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_resize_term_impl(module, nlines, ncols);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CURSES_RESIZE_TERM) */
+
+PyDoc_STRVAR(_curses_savetty__doc__,
+"savetty($module, /)\n"
+"--\n"
+"\n"
+"Save terminal mode.");
+
+#define _CURSES_SAVETTY_METHODDEF    \
+    {"savetty", (PyCFunction)_curses_savetty, METH_NOARGS, _curses_savetty__doc__},
+
+static PyObject *
+_curses_savetty_impl(PyObject *module);
+
+static PyObject *
+_curses_savetty(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_savetty_impl(module);
+}
+
+#if defined(getsyx)
+
+PyDoc_STRVAR(_curses_setsyx__doc__,
+"setsyx($module, y, x, /)\n"
+"--\n"
+"\n"
+"Set the virtual screen cursor.\n"
+"\n"
+"  y\n"
+"    Y-coordinate.\n"
+"  x\n"
+"    X-coordinate.\n"
+"\n"
+"If y and x are both -1, then leaveok is set.");
+
+#define _CURSES_SETSYX_METHODDEF    \
+    {"setsyx", _PyCFunction_CAST(_curses_setsyx), METH_FASTCALL, _curses_setsyx__doc__},
+
+static PyObject *
+_curses_setsyx_impl(PyObject *module, int y, int x);
+
+static PyObject *
+_curses_setsyx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int y;
+    int x;
+
+    if (!_PyArg_CheckPositional("setsyx", nargs, 2, 2)) {
+        goto exit;
+    }
+    y = _PyLong_AsInt(args[0]);
+    if (y == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    x = _PyLong_AsInt(args[1]);
+    if (x == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_setsyx_impl(module, y, x);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(getsyx) */
+
+PyDoc_STRVAR(_curses_start_color__doc__,
+"start_color($module, /)\n"
+"--\n"
+"\n"
+"Initializes eight basic colors and global variables COLORS and COLOR_PAIRS.\n"
+"\n"
+"Must be called if the programmer wants to use colors, and before any other\n"
+"color manipulation routine is called.  It is good practice to call this\n"
+"routine right after initscr().\n"
+"\n"
+"It also restores the colors on the terminal to the values they had when the\n"
+"terminal was just turned on.");
+
+#define _CURSES_START_COLOR_METHODDEF    \
+    {"start_color", (PyCFunction)_curses_start_color, METH_NOARGS, _curses_start_color__doc__},
+
+static PyObject *
+_curses_start_color_impl(PyObject *module);
+
+static PyObject *
+_curses_start_color(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_start_color_impl(module);
+}
+
+PyDoc_STRVAR(_curses_termattrs__doc__,
+"termattrs($module, /)\n"
+"--\n"
+"\n"
+"Return a logical OR of all video attributes supported by the terminal.");
+
+#define _CURSES_TERMATTRS_METHODDEF    \
+    {"termattrs", (PyCFunction)_curses_termattrs, METH_NOARGS, _curses_termattrs__doc__},
+
+static PyObject *
+_curses_termattrs_impl(PyObject *module);
+
+static PyObject *
+_curses_termattrs(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_termattrs_impl(module);
+}
+
+PyDoc_STRVAR(_curses_termname__doc__,
+"termname($module, /)\n"
+"--\n"
+"\n"
+"Return the value of the environment variable TERM, truncated to 14 characters.");
+
+#define _CURSES_TERMNAME_METHODDEF    \
+    {"termname", (PyCFunction)_curses_termname, METH_NOARGS, _curses_termname__doc__},
+
+static PyObject *
+_curses_termname_impl(PyObject *module);
+
+static PyObject *
+_curses_termname(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_termname_impl(module);
+}
+
+PyDoc_STRVAR(_curses_tigetflag__doc__,
+"tigetflag($module, capname, /)\n"
+"--\n"
+"\n"
+"Return the value of the Boolean capability.\n"
+"\n"
+"  capname\n"
+"    The terminfo capability name.\n"
+"\n"
+"The value -1 is returned if capname is not a Boolean capability, or 0 if\n"
+"it is canceled or absent from the terminal description.");
+
+#define _CURSES_TIGETFLAG_METHODDEF    \
+    {"tigetflag", (PyCFunction)_curses_tigetflag, METH_O, _curses_tigetflag__doc__},
+
+static PyObject *
+_curses_tigetflag_impl(PyObject *module, const char *capname);
+
+static PyObject *
+_curses_tigetflag(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *capname;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("tigetflag", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t capname_length;
+    capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
+    if (capname == NULL) {
+        goto exit;
+    }
+    if (strlen(capname) != (size_t)capname_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _curses_tigetflag_impl(module, capname);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_tigetnum__doc__,
+"tigetnum($module, capname, /)\n"
+"--\n"
+"\n"
+"Return the value of the numeric capability.\n"
+"\n"
+"  capname\n"
+"    The terminfo capability name.\n"
+"\n"
+"The value -2 is returned if capname is not a numeric capability, or -1 if\n"
+"it is canceled or absent from the terminal description.");
+
+#define _CURSES_TIGETNUM_METHODDEF    \
+    {"tigetnum", (PyCFunction)_curses_tigetnum, METH_O, _curses_tigetnum__doc__},
+
+static PyObject *
+_curses_tigetnum_impl(PyObject *module, const char *capname);
+
+static PyObject *
+_curses_tigetnum(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *capname;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("tigetnum", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t capname_length;
+    capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
+    if (capname == NULL) {
+        goto exit;
+    }
+    if (strlen(capname) != (size_t)capname_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _curses_tigetnum_impl(module, capname);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_tigetstr__doc__,
+"tigetstr($module, capname, /)\n"
+"--\n"
+"\n"
+"Return the value of the string capability.\n"
+"\n"
+"  capname\n"
+"    The terminfo capability name.\n"
+"\n"
+"None is returned if capname is not a string capability, or is canceled or\n"
+"absent from the terminal description.");
+
+#define _CURSES_TIGETSTR_METHODDEF    \
+    {"tigetstr", (PyCFunction)_curses_tigetstr, METH_O, _curses_tigetstr__doc__},
+
+static PyObject *
+_curses_tigetstr_impl(PyObject *module, const char *capname);
+
+static PyObject *
+_curses_tigetstr(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *capname;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("tigetstr", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t capname_length;
+    capname = PyUnicode_AsUTF8AndSize(arg, &capname_length);
+    if (capname == NULL) {
+        goto exit;
+    }
+    if (strlen(capname) != (size_t)capname_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _curses_tigetstr_impl(module, capname);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_curses_tparm__doc__,
+"tparm($module, str, i1=0, i2=0, i3=0, i4=0, i5=0, i6=0, i7=0, i8=0,\n"
+"      i9=0, /)\n"
+"--\n"
+"\n"
+"Instantiate the specified byte string with the supplied parameters.\n"
+"\n"
+"  str\n"
+"    Parameterized byte string obtained from the terminfo database.");
+
+#define _CURSES_TPARM_METHODDEF    \
+    {"tparm", _PyCFunction_CAST(_curses_tparm), METH_FASTCALL, _curses_tparm__doc__},
+
+static PyObject *
+_curses_tparm_impl(PyObject *module, const char *str, int i1, int i2, int i3,
+                   int i4, int i5, int i6, int i7, int i8, int i9);
+
+static PyObject *
+_curses_tparm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    const char *str;
+    int i1 = 0;
+    int i2 = 0;
+    int i3 = 0;
+    int i4 = 0;
+    int i5 = 0;
+    int i6 = 0;
+    int i7 = 0;
+    int i8 = 0;
+    int i9 = 0;
+
+    if (!_PyArg_ParseStack(args, nargs, "y|iiiiiiiii:tparm",
+        &str, &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8, &i9)) {
+        goto exit;
+    }
+    return_value = _curses_tparm_impl(module, str, i1, i2, i3, i4, i5, i6, i7, i8, i9);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_CURSES_TYPEAHEAD)
+
+PyDoc_STRVAR(_curses_typeahead__doc__,
+"typeahead($module, fd, /)\n"
+"--\n"
+"\n"
+"Specify that the file descriptor fd be used for typeahead checking.\n"
+"\n"
+"  fd\n"
+"    File descriptor.\n"
+"\n"
+"If fd is -1, then no typeahead checking is done.");
+
+#define _CURSES_TYPEAHEAD_METHODDEF    \
+    {"typeahead", (PyCFunction)_curses_typeahead, METH_O, _curses_typeahead__doc__},
+
+static PyObject *
+_curses_typeahead_impl(PyObject *module, int fd);
+
+static PyObject *
+_curses_typeahead(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int fd;
+
+    fd = _PyLong_AsInt(arg);
+    if (fd == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _curses_typeahead_impl(module, fd);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CURSES_TYPEAHEAD) */
+
+PyDoc_STRVAR(_curses_unctrl__doc__,
+"unctrl($module, ch, /)\n"
+"--\n"
+"\n"
+"Return a string which is a printable representation of the character ch.\n"
+"\n"
+"Control characters are displayed as a caret followed by the character,\n"
+"for example as ^C.  Printing characters are left as they are.");
+
+#define _CURSES_UNCTRL_METHODDEF    \
+    {"unctrl", (PyCFunction)_curses_unctrl, METH_O, _curses_unctrl__doc__},
+
+PyDoc_STRVAR(_curses_ungetch__doc__,
+"ungetch($module, ch, /)\n"
+"--\n"
+"\n"
+"Push ch so the next getch() will return it.");
+
+#define _CURSES_UNGETCH_METHODDEF    \
+    {"ungetch", (PyCFunction)_curses_ungetch, METH_O, _curses_ungetch__doc__},
+
+#if defined(HAVE_NCURSESW)
+
+PyDoc_STRVAR(_curses_unget_wch__doc__,
+"unget_wch($module, ch, /)\n"
+"--\n"
+"\n"
+"Push ch so the next get_wch() will return it.");
+
+#define _CURSES_UNGET_WCH_METHODDEF    \
+    {"unget_wch", (PyCFunction)_curses_unget_wch, METH_O, _curses_unget_wch__doc__},
+
+#endif /* defined(HAVE_NCURSESW) */
+
+#if defined(HAVE_CURSES_USE_ENV)
+
+PyDoc_STRVAR(_curses_use_env__doc__,
+"use_env($module, flag, /)\n"
+"--\n"
+"\n"
+"Use environment variables LINES and COLUMNS.\n"
+"\n"
+"If used, this function should be called before initscr() or newterm() are\n"
+"called.\n"
+"\n"
+"When flag is False, the values of lines and columns specified in the terminfo\n"
+"database will be used, even if environment variables LINES and COLUMNS (used\n"
+"by default) are set, or if curses is running in a window (in which case\n"
+"default behavior would be to use the window size if LINES and COLUMNS are\n"
+"not set).");
+
+#define _CURSES_USE_ENV_METHODDEF    \
+    {"use_env", (PyCFunction)_curses_use_env, METH_O, _curses_use_env__doc__},
+
+static PyObject *
+_curses_use_env_impl(PyObject *module, int flag);
+
+static PyObject *
+_curses_use_env(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int flag;
+
+    flag = PyObject_IsTrue(arg);
+    if (flag < 0) {
+        goto exit;
+    }
+    return_value = _curses_use_env_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CURSES_USE_ENV) */
+
+#if !defined(STRICT_SYSV_CURSES)
+
+PyDoc_STRVAR(_curses_use_default_colors__doc__,
+"use_default_colors($module, /)\n"
+"--\n"
+"\n"
+"Allow use of default values for colors on terminals supporting this feature.\n"
+"\n"
+"Use this to support transparency in your application.  The default color\n"
+"is assigned to the color number -1.");
+
+#define _CURSES_USE_DEFAULT_COLORS_METHODDEF    \
+    {"use_default_colors", (PyCFunction)_curses_use_default_colors, METH_NOARGS, _curses_use_default_colors__doc__},
+
+static PyObject *
+_curses_use_default_colors_impl(PyObject *module);
+
+static PyObject *
+_curses_use_default_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_use_default_colors_impl(module);
+}
+
+#endif /* !defined(STRICT_SYSV_CURSES) */
+
+PyDoc_STRVAR(_curses_has_extended_color_support__doc__,
+"has_extended_color_support($module, /)\n"
+"--\n"
+"\n"
+"Return True if the module supports extended colors; otherwise, return False.\n"
+"\n"
+"Extended color support allows more than 256 color-pairs for terminals\n"
+"that support more than 16 colors (e.g. xterm-256color).");
+
+#define _CURSES_HAS_EXTENDED_COLOR_SUPPORT_METHODDEF    \
+    {"has_extended_color_support", (PyCFunction)_curses_has_extended_color_support, METH_NOARGS, _curses_has_extended_color_support__doc__},
+
+static PyObject *
+_curses_has_extended_color_support_impl(PyObject *module);
+
+static PyObject *
+_curses_has_extended_color_support(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return _curses_has_extended_color_support_impl(module);
+}
+
+#ifndef _CURSES_WINDOW_ENCLOSE_METHODDEF
+    #define _CURSES_WINDOW_ENCLOSE_METHODDEF
+#endif /* !defined(_CURSES_WINDOW_ENCLOSE_METHODDEF) */
+
+#ifndef _CURSES_WINDOW_GET_WCH_METHODDEF
+    #define _CURSES_WINDOW_GET_WCH_METHODDEF
+#endif /* !defined(_CURSES_WINDOW_GET_WCH_METHODDEF) */
+
+#ifndef _CURSES_WINDOW_NOUTREFRESH_METHODDEF
+    #define _CURSES_WINDOW_NOUTREFRESH_METHODDEF
+#endif /* !defined(_CURSES_WINDOW_NOUTREFRESH_METHODDEF) */
+
+#ifndef _CURSES_FILTER_METHODDEF
+    #define _CURSES_FILTER_METHODDEF
+#endif /* !defined(_CURSES_FILTER_METHODDEF) */
+
+#ifndef _CURSES_GETSYX_METHODDEF
+    #define _CURSES_GETSYX_METHODDEF
+#endif /* !defined(_CURSES_GETSYX_METHODDEF) */
+
+#ifndef _CURSES_GETMOUSE_METHODDEF
+    #define _CURSES_GETMOUSE_METHODDEF
+#endif /* !defined(_CURSES_GETMOUSE_METHODDEF) */
+
+#ifndef _CURSES_UNGETMOUSE_METHODDEF
+    #define _CURSES_UNGETMOUSE_METHODDEF
+#endif /* !defined(_CURSES_UNGETMOUSE_METHODDEF) */
+
+#ifndef _CURSES_HAS_KEY_METHODDEF
+    #define _CURSES_HAS_KEY_METHODDEF
+#endif /* !defined(_CURSES_HAS_KEY_METHODDEF) */
+
+#ifndef _CURSES_GET_ESCDELAY_METHODDEF
+    #define _CURSES_GET_ESCDELAY_METHODDEF
+#endif /* !defined(_CURSES_GET_ESCDELAY_METHODDEF) */
+
+#ifndef _CURSES_SET_ESCDELAY_METHODDEF
+    #define _CURSES_SET_ESCDELAY_METHODDEF
+#endif /* !defined(_CURSES_SET_ESCDELAY_METHODDEF) */
+
+#ifndef _CURSES_GET_TABSIZE_METHODDEF
+    #define _CURSES_GET_TABSIZE_METHODDEF
+#endif /* !defined(_CURSES_GET_TABSIZE_METHODDEF) */
+
+#ifndef _CURSES_SET_TABSIZE_METHODDEF
+    #define _CURSES_SET_TABSIZE_METHODDEF
+#endif /* !defined(_CURSES_SET_TABSIZE_METHODDEF) */
+
+#ifndef _CURSES_IS_TERM_RESIZED_METHODDEF
+    #define _CURSES_IS_TERM_RESIZED_METHODDEF
+#endif /* !defined(_CURSES_IS_TERM_RESIZED_METHODDEF) */
+
+#ifndef _CURSES_MOUSEINTERVAL_METHODDEF
+    #define _CURSES_MOUSEINTERVAL_METHODDEF
+#endif /* !defined(_CURSES_MOUSEINTERVAL_METHODDEF) */
+
+#ifndef _CURSES_MOUSEMASK_METHODDEF
+    #define _CURSES_MOUSEMASK_METHODDEF
+#endif /* !defined(_CURSES_MOUSEMASK_METHODDEF) */
+
+#ifndef _CURSES_UPDATE_LINES_COLS_METHODDEF
+    #define _CURSES_UPDATE_LINES_COLS_METHODDEF
+#endif /* !defined(_CURSES_UPDATE_LINES_COLS_METHODDEF) */
+
+#ifndef _CURSES_RESIZETERM_METHODDEF
+    #define _CURSES_RESIZETERM_METHODDEF
+#endif /* !defined(_CURSES_RESIZETERM_METHODDEF) */
+
+#ifndef _CURSES_RESIZE_TERM_METHODDEF
+    #define _CURSES_RESIZE_TERM_METHODDEF
+#endif /* !defined(_CURSES_RESIZE_TERM_METHODDEF) */
+
+#ifndef _CURSES_SETSYX_METHODDEF
+    #define _CURSES_SETSYX_METHODDEF
+#endif /* !defined(_CURSES_SETSYX_METHODDEF) */
+
+#ifndef _CURSES_TYPEAHEAD_METHODDEF
+    #define _CURSES_TYPEAHEAD_METHODDEF
+#endif /* !defined(_CURSES_TYPEAHEAD_METHODDEF) */
+
+#ifndef _CURSES_UNGET_WCH_METHODDEF
+    #define _CURSES_UNGET_WCH_METHODDEF
+#endif /* !defined(_CURSES_UNGET_WCH_METHODDEF) */
+
+#ifndef _CURSES_USE_ENV_METHODDEF
+    #define _CURSES_USE_ENV_METHODDEF
+#endif /* !defined(_CURSES_USE_ENV_METHODDEF) */
+
+#ifndef _CURSES_USE_DEFAULT_COLORS_METHODDEF
+    #define _CURSES_USE_DEFAULT_COLORS_METHODDEF
+#endif /* !defined(_CURSES_USE_DEFAULT_COLORS_METHODDEF) */
+/*[clinic end generated code: output=27a2364193b503c1 input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_dbmmodule.c.h b/contrib/tools/python3/Modules/clinic/_dbmmodule.c.h
new file mode 100644
index 00000000000..a880e3cebfb
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_dbmmodule.c.h
@@ -0,0 +1,203 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_dbm_dbm_close__doc__,
+"close($self, /)\n"
+"--\n"
+"\n"
+"Close the database.");
+
+#define _DBM_DBM_CLOSE_METHODDEF    \
+    {"close", (PyCFunction)_dbm_dbm_close, METH_NOARGS, _dbm_dbm_close__doc__},
+
+static PyObject *
+_dbm_dbm_close_impl(dbmobject *self);
+
+static PyObject *
+_dbm_dbm_close(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _dbm_dbm_close_impl(self);
+}
+
+PyDoc_STRVAR(_dbm_dbm_keys__doc__,
+"keys($self, /)\n"
+"--\n"
+"\n"
+"Return a list of all keys in the database.");
+
+#define _DBM_DBM_KEYS_METHODDEF    \
+    {"keys", _PyCFunction_CAST(_dbm_dbm_keys), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _dbm_dbm_keys__doc__},
+
+static PyObject *
+_dbm_dbm_keys_impl(dbmobject *self, PyTypeObject *cls);
+
+static PyObject *
+_dbm_dbm_keys(dbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "keys() takes no arguments");
+        return NULL;
+    }
+    return _dbm_dbm_keys_impl(self, cls);
+}
+
+PyDoc_STRVAR(_dbm_dbm_get__doc__,
+"get($self, key, default=None, /)\n"
+"--\n"
+"\n"
+"Return the value for key if present, otherwise default.");
+
+#define _DBM_DBM_GET_METHODDEF    \
+    {"get", _PyCFunction_CAST(_dbm_dbm_get), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _dbm_dbm_get__doc__},
+
+static PyObject *
+_dbm_dbm_get_impl(dbmobject *self, PyTypeObject *cls, const char *key,
+                  Py_ssize_t key_length, PyObject *default_value);
+
+static PyObject *
+_dbm_dbm_get(dbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", "", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .format = "s#|O:get",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    const char *key;
+    Py_ssize_t key_length;
+    PyObject *default_value = Py_None;
+
+    if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
+        &key, &key_length, &default_value)) {
+        goto exit;
+    }
+    return_value = _dbm_dbm_get_impl(self, cls, key, key_length, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_dbm_dbm_setdefault__doc__,
+"setdefault($self, key, default=b\'\', /)\n"
+"--\n"
+"\n"
+"Return the value for key if present, otherwise default.\n"
+"\n"
+"If key is not in the database, it is inserted with default as the value.");
+
+#define _DBM_DBM_SETDEFAULT_METHODDEF    \
+    {"setdefault", _PyCFunction_CAST(_dbm_dbm_setdefault), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _dbm_dbm_setdefault__doc__},
+
+static PyObject *
+_dbm_dbm_setdefault_impl(dbmobject *self, PyTypeObject *cls, const char *key,
+                         Py_ssize_t key_length, PyObject *default_value);
+
+static PyObject *
+_dbm_dbm_setdefault(dbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", "", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .format = "s#|O:setdefault",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    const char *key;
+    Py_ssize_t key_length;
+    PyObject *default_value = NULL;
+
+    if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
+        &key, &key_length, &default_value)) {
+        goto exit;
+    }
+    return_value = _dbm_dbm_setdefault_impl(self, cls, key, key_length, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(dbmopen__doc__,
+"open($module, filename, flags=\'r\', mode=0o666, /)\n"
+"--\n"
+"\n"
+"Return a database object.\n"
+"\n"
+"  filename\n"
+"    The filename to open.\n"
+"  flags\n"
+"    How to open the file.  \"r\" for reading, \"w\" for writing, etc.\n"
+"  mode\n"
+"    If creating a new file, the mode bits for the new file\n"
+"    (e.g. os.O_RDWR).");
+
+#define DBMOPEN_METHODDEF    \
+    {"open", _PyCFunction_CAST(dbmopen), METH_FASTCALL, dbmopen__doc__},
+
+static PyObject *
+dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
+             int mode);
+
+static PyObject *
+dbmopen(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *filename;
+    const char *flags = "r";
+    int mode = 438;
+
+    if (!_PyArg_CheckPositional("open", nargs, 1, 3)) {
+        goto exit;
+    }
+    filename = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!PyUnicode_Check(args[1])) {
+        _PyArg_BadArgument("open", "argument 2", "str", args[1]);
+        goto exit;
+    }
+    Py_ssize_t flags_length;
+    flags = PyUnicode_AsUTF8AndSize(args[1], &flags_length);
+    if (flags == NULL) {
+        goto exit;
+    }
+    if (strlen(flags) != (size_t)flags_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    mode = _PyLong_AsInt(args[2]);
+    if (mode == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = dbmopen_impl(module, filename, flags, mode);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=f924d467af2e2f4e input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_gdbmmodule.c.h b/contrib/tools/python3/Modules/clinic/_gdbmmodule.c.h
new file mode 100644
index 00000000000..e5d6b075dbc
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_gdbmmodule.c.h
@@ -0,0 +1,325 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_gdbm_gdbm_get__doc__,
+"get($self, key, default=None, /)\n"
+"--\n"
+"\n"
+"Get the value for key, or default if not present.");
+
+#define _GDBM_GDBM_GET_METHODDEF    \
+    {"get", _PyCFunction_CAST(_gdbm_gdbm_get), METH_FASTCALL, _gdbm_gdbm_get__doc__},
+
+static PyObject *
+_gdbm_gdbm_get_impl(gdbmobject *self, PyObject *key, PyObject *default_value);
+
+static PyObject *
+_gdbm_gdbm_get(gdbmobject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *key;
+    PyObject *default_value = Py_None;
+
+    if (!_PyArg_CheckPositional("get", nargs, 1, 2)) {
+        goto exit;
+    }
+    key = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    default_value = args[1];
+skip_optional:
+    return_value = _gdbm_gdbm_get_impl(self, key, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_setdefault__doc__,
+"setdefault($self, key, default=None, /)\n"
+"--\n"
+"\n"
+"Get value for key, or set it to default and return default if not present.");
+
+#define _GDBM_GDBM_SETDEFAULT_METHODDEF    \
+    {"setdefault", _PyCFunction_CAST(_gdbm_gdbm_setdefault), METH_FASTCALL, _gdbm_gdbm_setdefault__doc__},
+
+static PyObject *
+_gdbm_gdbm_setdefault_impl(gdbmobject *self, PyObject *key,
+                           PyObject *default_value);
+
+static PyObject *
+_gdbm_gdbm_setdefault(gdbmobject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *key;
+    PyObject *default_value = Py_None;
+
+    if (!_PyArg_CheckPositional("setdefault", nargs, 1, 2)) {
+        goto exit;
+    }
+    key = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    default_value = args[1];
+skip_optional:
+    return_value = _gdbm_gdbm_setdefault_impl(self, key, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_close__doc__,
+"close($self, /)\n"
+"--\n"
+"\n"
+"Close the database.");
+
+#define _GDBM_GDBM_CLOSE_METHODDEF    \
+    {"close", (PyCFunction)_gdbm_gdbm_close, METH_NOARGS, _gdbm_gdbm_close__doc__},
+
+static PyObject *
+_gdbm_gdbm_close_impl(gdbmobject *self);
+
+static PyObject *
+_gdbm_gdbm_close(gdbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _gdbm_gdbm_close_impl(self);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_keys__doc__,
+"keys($self, /)\n"
+"--\n"
+"\n"
+"Get a list of all keys in the database.");
+
+#define _GDBM_GDBM_KEYS_METHODDEF    \
+    {"keys", _PyCFunction_CAST(_gdbm_gdbm_keys), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _gdbm_gdbm_keys__doc__},
+
+static PyObject *
+_gdbm_gdbm_keys_impl(gdbmobject *self, PyTypeObject *cls);
+
+static PyObject *
+_gdbm_gdbm_keys(gdbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "keys() takes no arguments");
+        return NULL;
+    }
+    return _gdbm_gdbm_keys_impl(self, cls);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_firstkey__doc__,
+"firstkey($self, /)\n"
+"--\n"
+"\n"
+"Return the starting key for the traversal.\n"
+"\n"
+"It\'s possible to loop over every key in the database using this method\n"
+"and the nextkey() method.  The traversal is ordered by GDBM\'s internal\n"
+"hash values, and won\'t be sorted by the key values.");
+
+#define _GDBM_GDBM_FIRSTKEY_METHODDEF    \
+    {"firstkey", _PyCFunction_CAST(_gdbm_gdbm_firstkey), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _gdbm_gdbm_firstkey__doc__},
+
+static PyObject *
+_gdbm_gdbm_firstkey_impl(gdbmobject *self, PyTypeObject *cls);
+
+static PyObject *
+_gdbm_gdbm_firstkey(gdbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "firstkey() takes no arguments");
+        return NULL;
+    }
+    return _gdbm_gdbm_firstkey_impl(self, cls);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_nextkey__doc__,
+"nextkey($self, key, /)\n"
+"--\n"
+"\n"
+"Returns the key that follows key in the traversal.\n"
+"\n"
+"The following code prints every key in the database db, without having\n"
+"to create a list in memory that contains them all:\n"
+"\n"
+"      k = db.firstkey()\n"
+"      while k is not None:\n"
+"          print(k)\n"
+"          k = db.nextkey(k)");
+
+#define _GDBM_GDBM_NEXTKEY_METHODDEF    \
+    {"nextkey", _PyCFunction_CAST(_gdbm_gdbm_nextkey), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _gdbm_gdbm_nextkey__doc__},
+
+static PyObject *
+_gdbm_gdbm_nextkey_impl(gdbmobject *self, PyTypeObject *cls, const char *key,
+                        Py_ssize_t key_length);
+
+static PyObject *
+_gdbm_gdbm_nextkey(gdbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+    #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+    #else
+    #  define KWTUPLE NULL
+    #endif
+
+    static const char * const _keywords[] = {"", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .format = "s#:nextkey",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    const char *key;
+    Py_ssize_t key_length;
+
+    if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
+        &key, &key_length)) {
+        goto exit;
+    }
+    return_value = _gdbm_gdbm_nextkey_impl(self, cls, key, key_length);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_reorganize__doc__,
+"reorganize($self, /)\n"
+"--\n"
+"\n"
+"Reorganize the database.\n"
+"\n"
+"If you have carried out a lot of deletions and would like to shrink\n"
+"the space used by the GDBM file, this routine will reorganize the\n"
+"database.  GDBM will not shorten the length of a database file except\n"
+"by using this reorganization; otherwise, deleted file space will be\n"
+"kept and reused as new (key,value) pairs are added.");
+
+#define _GDBM_GDBM_REORGANIZE_METHODDEF    \
+    {"reorganize", _PyCFunction_CAST(_gdbm_gdbm_reorganize), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _gdbm_gdbm_reorganize__doc__},
+
+static PyObject *
+_gdbm_gdbm_reorganize_impl(gdbmobject *self, PyTypeObject *cls);
+
+static PyObject *
+_gdbm_gdbm_reorganize(gdbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "reorganize() takes no arguments");
+        return NULL;
+    }
+    return _gdbm_gdbm_reorganize_impl(self, cls);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_sync__doc__,
+"sync($self, /)\n"
+"--\n"
+"\n"
+"Flush the database to the disk file.\n"
+"\n"
+"When the database has been opened in fast mode, this method forces\n"
+"any unwritten data to be written to the disk.");
+
+#define _GDBM_GDBM_SYNC_METHODDEF    \
+    {"sync", _PyCFunction_CAST(_gdbm_gdbm_sync), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _gdbm_gdbm_sync__doc__},
+
+static PyObject *
+_gdbm_gdbm_sync_impl(gdbmobject *self, PyTypeObject *cls);
+
+static PyObject *
+_gdbm_gdbm_sync(gdbmobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "sync() takes no arguments");
+        return NULL;
+    }
+    return _gdbm_gdbm_sync_impl(self, cls);
+}
+
+PyDoc_STRVAR(dbmopen__doc__,
+"open($module, filename, flags=\'r\', mode=0o666, /)\n"
+"--\n"
+"\n"
+"Open a dbm database and return a dbm object.\n"
+"\n"
+"The filename argument is the name of the database file.\n"
+"\n"
+"The optional flags argument can be \'r\' (to open an existing database\n"
+"for reading only -- default), \'w\' (to open an existing database for\n"
+"reading and writing), \'c\' (which creates the database if it doesn\'t\n"
+"exist), or \'n\' (which always creates a new empty database).\n"
+"\n"
+"Some versions of gdbm support additional flags which must be\n"
+"appended to one of the flags described above.  The module constant\n"
+"\'open_flags\' is a string of valid additional flags.  The \'f\' flag\n"
+"opens the database in fast mode; altered data will not automatically\n"
+"be written to the disk after every change.  This results in faster\n"
+"writes to the database, but may result in an inconsistent database\n"
+"if the program crashes while the database is still open.  Use the\n"
+"sync() method to force any unwritten data to be written to the disk.\n"
+"The \'s\' flag causes all database operations to be synchronized to\n"
+"disk.  The \'u\' flag disables locking of the database file.\n"
+"\n"
+"The optional mode argument is the Unix mode of the file, used only\n"
+"when the database has to be created.  It defaults to octal 0o666.");
+
+#define DBMOPEN_METHODDEF    \
+    {"open", _PyCFunction_CAST(dbmopen), METH_FASTCALL, dbmopen__doc__},
+
+static PyObject *
+dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
+             int mode);
+
+static PyObject *
+dbmopen(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *filename;
+    const char *flags = "r";
+    int mode = 438;
+
+    if (!_PyArg_CheckPositional("open", nargs, 1, 3)) {
+        goto exit;
+    }
+    filename = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!PyUnicode_Check(args[1])) {
+        _PyArg_BadArgument("open", "argument 2", "str", args[1]);
+        goto exit;
+    }
+    Py_ssize_t flags_length;
+    flags = PyUnicode_AsUTF8AndSize(args[1], &flags_length);
+    if (flags == NULL) {
+        goto exit;
+    }
+    if (strlen(flags) != (size_t)flags_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    mode = _PyLong_AsInt(args[2]);
+    if (mode == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = dbmopen_impl(module, filename, flags, mode);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=37665074bba905bf input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_testclinic.c.h b/contrib/tools/python3/Modules/clinic/_testclinic.c.h
new file mode 100644
index 00000000000..a9bcbf753d2
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_testclinic.c.h
@@ -0,0 +1,3172 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(test_empty_function__doc__,
+"test_empty_function($module, /)\n"
+"--\n"
+"\n");
+
+#define TEST_EMPTY_FUNCTION_METHODDEF    \
+    {"test_empty_function", (PyCFunction)test_empty_function, METH_NOARGS, test_empty_function__doc__},
+
+static PyObject *
+test_empty_function_impl(PyObject *module);
+
+static PyObject *
+test_empty_function(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return test_empty_function_impl(module);
+}
+
+PyDoc_STRVAR(objects_converter__doc__,
+"objects_converter($module, a, b=<unrepresentable>, /)\n"
+"--\n"
+"\n");
+
+#define OBJECTS_CONVERTER_METHODDEF    \
+    {"objects_converter", _PyCFunction_CAST(objects_converter), METH_FASTCALL, objects_converter__doc__},
+
+static PyObject *
+objects_converter_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+objects_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b = NULL;
+
+    if (!_PyArg_CheckPositional("objects_converter", nargs, 1, 2)) {
+        goto exit;
+    }
+    a = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    b = args[1];
+skip_optional:
+    return_value = objects_converter_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(bytes_object_converter__doc__,
+"bytes_object_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define BYTES_OBJECT_CONVERTER_METHODDEF    \
+    {"bytes_object_converter", (PyCFunction)bytes_object_converter, METH_O, bytes_object_converter__doc__},
+
+static PyObject *
+bytes_object_converter_impl(PyObject *module, PyBytesObject *a);
+
+static PyObject *
+bytes_object_converter(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    PyBytesObject *a;
+
+    if (!PyBytes_Check(arg)) {
+        _PyArg_BadArgument("bytes_object_converter", "argument", "bytes", arg);
+        goto exit;
+    }
+    a = (PyBytesObject *)arg;
+    return_value = bytes_object_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(byte_array_object_converter__doc__,
+"byte_array_object_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define BYTE_ARRAY_OBJECT_CONVERTER_METHODDEF    \
+    {"byte_array_object_converter", (PyCFunction)byte_array_object_converter, METH_O, byte_array_object_converter__doc__},
+
+static PyObject *
+byte_array_object_converter_impl(PyObject *module, PyByteArrayObject *a);
+
+static PyObject *
+byte_array_object_converter(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    PyByteArrayObject *a;
+
+    if (!PyByteArray_Check(arg)) {
+        _PyArg_BadArgument("byte_array_object_converter", "argument", "bytearray", arg);
+        goto exit;
+    }
+    a = (PyByteArrayObject *)arg;
+    return_value = byte_array_object_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(unicode_converter__doc__,
+"unicode_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define UNICODE_CONVERTER_METHODDEF    \
+    {"unicode_converter", (PyCFunction)unicode_converter, METH_O, unicode_converter__doc__},
+
+static PyObject *
+unicode_converter_impl(PyObject *module, PyObject *a);
+
+static PyObject *
+unicode_converter(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("unicode_converter", "argument", "str", arg);
+        goto exit;
+    }
+    if (PyUnicode_READY(arg) == -1) {
+        goto exit;
+    }
+    a = arg;
+    return_value = unicode_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(bool_converter__doc__,
+"bool_converter($module, a=True, b=True, c=True, /)\n"
+"--\n"
+"\n");
+
+#define BOOL_CONVERTER_METHODDEF    \
+    {"bool_converter", _PyCFunction_CAST(bool_converter), METH_FASTCALL, bool_converter__doc__},
+
+static PyObject *
+bool_converter_impl(PyObject *module, int a, int b, int c);
+
+static PyObject *
+bool_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int a = 1;
+    int b = 1;
+    int c = 1;
+
+    if (!_PyArg_CheckPositional("bool_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    a = PyObject_IsTrue(args[0]);
+    if (a < 0) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    b = PyObject_IsTrue(args[1]);
+    if (b < 0) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    c = _PyLong_AsInt(args[2]);
+    if (c == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = bool_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(char_converter__doc__,
+"char_converter($module, a=b\'A\', b=b\'\\x07\', c=b\'\\x08\', d=b\'\\t\', e=b\'\\n\',\n"
+"               f=b\'\\x0b\', g=b\'\\x0c\', h=b\'\\r\', i=b\'\"\', j=b\"\'\", k=b\'?\',\n"
+"               l=b\'\\\\\', m=b\'\\x00\', n=b\'\\xff\', /)\n"
+"--\n"
+"\n");
+
+#define CHAR_CONVERTER_METHODDEF    \
+    {"char_converter", _PyCFunction_CAST(char_converter), METH_FASTCALL, char_converter__doc__},
+
+static PyObject *
+char_converter_impl(PyObject *module, char a, char b, char c, char d, char e,
+                    char f, char g, char h, char i, char j, char k, char l,
+                    char m, char n);
+
+static PyObject *
+char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    char a = 'A';
+    char b = '\x07';
+    char c = '\x08';
+    char d = '\t';
+    char e = '\n';
+    char f = '\x0b';
+    char g = '\x0c';
+    char h = '\r';
+    char i = '"';
+    char j = '\'';
+    char k = '?';
+    char l = '\\';
+    char m = '\x00';
+    char n = '\xff';
+
+    if (!_PyArg_CheckPositional("char_converter", nargs, 0, 14)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[0]) && PyBytes_GET_SIZE(args[0]) == 1) {
+        a = PyBytes_AS_STRING(args[0])[0];
+    }
+    else if (PyByteArray_Check(args[0]) && PyByteArray_GET_SIZE(args[0]) == 1) {
+        a = PyByteArray_AS_STRING(args[0])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 1", "a byte string of length 1", args[0]);
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[1]) && PyBytes_GET_SIZE(args[1]) == 1) {
+        b = PyBytes_AS_STRING(args[1])[0];
+    }
+    else if (PyByteArray_Check(args[1]) && PyByteArray_GET_SIZE(args[1]) == 1) {
+        b = PyByteArray_AS_STRING(args[1])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 2", "a byte string of length 1", args[1]);
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[2]) && PyBytes_GET_SIZE(args[2]) == 1) {
+        c = PyBytes_AS_STRING(args[2])[0];
+    }
+    else if (PyByteArray_Check(args[2]) && PyByteArray_GET_SIZE(args[2]) == 1) {
+        c = PyByteArray_AS_STRING(args[2])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 3", "a byte string of length 1", args[2]);
+        goto exit;
+    }
+    if (nargs < 4) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[3]) && PyBytes_GET_SIZE(args[3]) == 1) {
+        d = PyBytes_AS_STRING(args[3])[0];
+    }
+    else if (PyByteArray_Check(args[3]) && PyByteArray_GET_SIZE(args[3]) == 1) {
+        d = PyByteArray_AS_STRING(args[3])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 4", "a byte string of length 1", args[3]);
+        goto exit;
+    }
+    if (nargs < 5) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[4]) && PyBytes_GET_SIZE(args[4]) == 1) {
+        e = PyBytes_AS_STRING(args[4])[0];
+    }
+    else if (PyByteArray_Check(args[4]) && PyByteArray_GET_SIZE(args[4]) == 1) {
+        e = PyByteArray_AS_STRING(args[4])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 5", "a byte string of length 1", args[4]);
+        goto exit;
+    }
+    if (nargs < 6) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[5]) && PyBytes_GET_SIZE(args[5]) == 1) {
+        f = PyBytes_AS_STRING(args[5])[0];
+    }
+    else if (PyByteArray_Check(args[5]) && PyByteArray_GET_SIZE(args[5]) == 1) {
+        f = PyByteArray_AS_STRING(args[5])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 6", "a byte string of length 1", args[5]);
+        goto exit;
+    }
+    if (nargs < 7) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[6]) && PyBytes_GET_SIZE(args[6]) == 1) {
+        g = PyBytes_AS_STRING(args[6])[0];
+    }
+    else if (PyByteArray_Check(args[6]) && PyByteArray_GET_SIZE(args[6]) == 1) {
+        g = PyByteArray_AS_STRING(args[6])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 7", "a byte string of length 1", args[6]);
+        goto exit;
+    }
+    if (nargs < 8) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[7]) && PyBytes_GET_SIZE(args[7]) == 1) {
+        h = PyBytes_AS_STRING(args[7])[0];
+    }
+    else if (PyByteArray_Check(args[7]) && PyByteArray_GET_SIZE(args[7]) == 1) {
+        h = PyByteArray_AS_STRING(args[7])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 8", "a byte string of length 1", args[7]);
+        goto exit;
+    }
+    if (nargs < 9) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[8]) && PyBytes_GET_SIZE(args[8]) == 1) {
+        i = PyBytes_AS_STRING(args[8])[0];
+    }
+    else if (PyByteArray_Check(args[8]) && PyByteArray_GET_SIZE(args[8]) == 1) {
+        i = PyByteArray_AS_STRING(args[8])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 9", "a byte string of length 1", args[8]);
+        goto exit;
+    }
+    if (nargs < 10) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[9]) && PyBytes_GET_SIZE(args[9]) == 1) {
+        j = PyBytes_AS_STRING(args[9])[0];
+    }
+    else if (PyByteArray_Check(args[9]) && PyByteArray_GET_SIZE(args[9]) == 1) {
+        j = PyByteArray_AS_STRING(args[9])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 10", "a byte string of length 1", args[9]);
+        goto exit;
+    }
+    if (nargs < 11) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[10]) && PyBytes_GET_SIZE(args[10]) == 1) {
+        k = PyBytes_AS_STRING(args[10])[0];
+    }
+    else if (PyByteArray_Check(args[10]) && PyByteArray_GET_SIZE(args[10]) == 1) {
+        k = PyByteArray_AS_STRING(args[10])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 11", "a byte string of length 1", args[10]);
+        goto exit;
+    }
+    if (nargs < 12) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[11]) && PyBytes_GET_SIZE(args[11]) == 1) {
+        l = PyBytes_AS_STRING(args[11])[0];
+    }
+    else if (PyByteArray_Check(args[11]) && PyByteArray_GET_SIZE(args[11]) == 1) {
+        l = PyByteArray_AS_STRING(args[11])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 12", "a byte string of length 1", args[11]);
+        goto exit;
+    }
+    if (nargs < 13) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[12]) && PyBytes_GET_SIZE(args[12]) == 1) {
+        m = PyBytes_AS_STRING(args[12])[0];
+    }
+    else if (PyByteArray_Check(args[12]) && PyByteArray_GET_SIZE(args[12]) == 1) {
+        m = PyByteArray_AS_STRING(args[12])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 13", "a byte string of length 1", args[12]);
+        goto exit;
+    }
+    if (nargs < 14) {
+        goto skip_optional;
+    }
+    if (PyBytes_Check(args[13]) && PyBytes_GET_SIZE(args[13]) == 1) {
+        n = PyBytes_AS_STRING(args[13])[0];
+    }
+    else if (PyByteArray_Check(args[13]) && PyByteArray_GET_SIZE(args[13]) == 1) {
+        n = PyByteArray_AS_STRING(args[13])[0];
+    }
+    else {
+        _PyArg_BadArgument("char_converter", "argument 14", "a byte string of length 1", args[13]);
+        goto exit;
+    }
+skip_optional:
+    return_value = char_converter_impl(module, a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(unsigned_char_converter__doc__,
+"unsigned_char_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_CHAR_CONVERTER_METHODDEF    \
+    {"unsigned_char_converter", _PyCFunction_CAST(unsigned_char_converter), METH_FASTCALL, unsigned_char_converter__doc__},
+
+static PyObject *
+unsigned_char_converter_impl(PyObject *module, unsigned char a,
+                             unsigned char b, unsigned char c);
+
+static PyObject *
+unsigned_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    unsigned char a = 12;
+    unsigned char b = 34;
+    unsigned char c = 56;
+
+    if (!_PyArg_CheckPositional("unsigned_char_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    {
+        long ival = PyLong_AsLong(args[0]);
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        else if (ival < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "unsigned byte integer is less than minimum");
+            goto exit;
+        }
+        else if (ival > UCHAR_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "unsigned byte integer is greater than maximum");
+            goto exit;
+        }
+        else {
+            a = (unsigned char) ival;
+        }
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    {
+        long ival = PyLong_AsLong(args[1]);
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        else if (ival < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "unsigned byte integer is less than minimum");
+            goto exit;
+        }
+        else if (ival > UCHAR_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "unsigned byte integer is greater than maximum");
+            goto exit;
+        }
+        else {
+            b = (unsigned char) ival;
+        }
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    {
+        unsigned long ival = PyLong_AsUnsignedLongMask(args[2]);
+        if (ival == (unsigned long)-1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        else {
+            c = (unsigned char) ival;
+        }
+    }
+skip_optional:
+    return_value = unsigned_char_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(short_converter__doc__,
+"short_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define SHORT_CONVERTER_METHODDEF    \
+    {"short_converter", _PyCFunction_CAST(short_converter), METH_FASTCALL, short_converter__doc__},
+
+static PyObject *
+short_converter_impl(PyObject *module, short a);
+
+static PyObject *
+short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    short a = 12;
+
+    if (!_PyArg_CheckPositional("short_converter", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    {
+        long ival = PyLong_AsLong(args[0]);
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        else if (ival < SHRT_MIN) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "signed short integer is less than minimum");
+            goto exit;
+        }
+        else if (ival > SHRT_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "signed short integer is greater than maximum");
+            goto exit;
+        }
+        else {
+            a = (short) ival;
+        }
+    }
+skip_optional:
+    return_value = short_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(unsigned_short_converter__doc__,
+"unsigned_short_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_SHORT_CONVERTER_METHODDEF    \
+    {"unsigned_short_converter", _PyCFunction_CAST(unsigned_short_converter), METH_FASTCALL, unsigned_short_converter__doc__},
+
+static PyObject *
+unsigned_short_converter_impl(PyObject *module, unsigned short a,
+                              unsigned short b, unsigned short c);
+
+static PyObject *
+unsigned_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    unsigned short a = 12;
+    unsigned short b = 34;
+    unsigned short c = 56;
+
+    if (!_PyArg_CheckPositional("unsigned_short_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedShort_Converter(args[0], &a)) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedShort_Converter(args[1], &b)) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    c = (unsigned short)PyLong_AsUnsignedLongMask(args[2]);
+    if (c == (unsigned short)-1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = unsigned_short_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(int_converter__doc__,
+"int_converter($module, a=12, b=34, c=45, /)\n"
+"--\n"
+"\n");
+
+#define INT_CONVERTER_METHODDEF    \
+    {"int_converter", _PyCFunction_CAST(int_converter), METH_FASTCALL, int_converter__doc__},
+
+static PyObject *
+int_converter_impl(PyObject *module, int a, int b, int c);
+
+static PyObject *
+int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int a = 12;
+    int b = 34;
+    int c = 45;
+
+    if (!_PyArg_CheckPositional("int_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    a = _PyLong_AsInt(args[0]);
+    if (a == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    b = _PyLong_AsInt(args[1]);
+    if (b == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (!PyUnicode_Check(args[2])) {
+        _PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);
+        goto exit;
+    }
+    if (PyUnicode_READY(args[2])) {
+        goto exit;
+    }
+    if (PyUnicode_GET_LENGTH(args[2]) != 1) {
+        _PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);
+        goto exit;
+    }
+    c = PyUnicode_READ_CHAR(args[2], 0);
+skip_optional:
+    return_value = int_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(unsigned_int_converter__doc__,
+"unsigned_int_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_INT_CONVERTER_METHODDEF    \
+    {"unsigned_int_converter", _PyCFunction_CAST(unsigned_int_converter), METH_FASTCALL, unsigned_int_converter__doc__},
+
+static PyObject *
+unsigned_int_converter_impl(PyObject *module, unsigned int a, unsigned int b,
+                            unsigned int c);
+
+static PyObject *
+unsigned_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    unsigned int a = 12;
+    unsigned int b = 34;
+    unsigned int c = 56;
+
+    if (!_PyArg_CheckPositional("unsigned_int_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedInt_Converter(args[0], &a)) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedInt_Converter(args[1], &b)) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    c = (unsigned int)PyLong_AsUnsignedLongMask(args[2]);
+    if (c == (unsigned int)-1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = unsigned_int_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(long_converter__doc__,
+"long_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define LONG_CONVERTER_METHODDEF    \
+    {"long_converter", _PyCFunction_CAST(long_converter), METH_FASTCALL, long_converter__doc__},
+
+static PyObject *
+long_converter_impl(PyObject *module, long a);
+
+static PyObject *
+long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    long a = 12;
+
+    if (!_PyArg_CheckPositional("long_converter", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    a = PyLong_AsLong(args[0]);
+    if (a == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = long_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(unsigned_long_converter__doc__,
+"unsigned_long_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_LONG_CONVERTER_METHODDEF    \
+    {"unsigned_long_converter", _PyCFunction_CAST(unsigned_long_converter), METH_FASTCALL, unsigned_long_converter__doc__},
+
+static PyObject *
+unsigned_long_converter_impl(PyObject *module, unsigned long a,
+                             unsigned long b, unsigned long c);
+
+static PyObject *
+unsigned_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    unsigned long a = 12;
+    unsigned long b = 34;
+    unsigned long c = 56;
+
+    if (!_PyArg_CheckPositional("unsigned_long_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedLong_Converter(args[0], &a)) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedLong_Converter(args[1], &b)) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (!PyLong_Check(args[2])) {
+        _PyArg_BadArgument("unsigned_long_converter", "argument 3", "int", args[2]);
+        goto exit;
+    }
+    c = PyLong_AsUnsignedLongMask(args[2]);
+skip_optional:
+    return_value = unsigned_long_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(long_long_converter__doc__,
+"long_long_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define LONG_LONG_CONVERTER_METHODDEF    \
+    {"long_long_converter", _PyCFunction_CAST(long_long_converter), METH_FASTCALL, long_long_converter__doc__},
+
+static PyObject *
+long_long_converter_impl(PyObject *module, long long a);
+
+static PyObject *
+long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    long long a = 12;
+
+    if (!_PyArg_CheckPositional("long_long_converter", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    a = PyLong_AsLongLong(args[0]);
+    if (a == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = long_long_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(unsigned_long_long_converter__doc__,
+"unsigned_long_long_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_LONG_LONG_CONVERTER_METHODDEF    \
+    {"unsigned_long_long_converter", _PyCFunction_CAST(unsigned_long_long_converter), METH_FASTCALL, unsigned_long_long_converter__doc__},
+
+static PyObject *
+unsigned_long_long_converter_impl(PyObject *module, unsigned long long a,
+                                  unsigned long long b, unsigned long long c);
+
+static PyObject *
+unsigned_long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    unsigned long long a = 12;
+    unsigned long long b = 34;
+    unsigned long long c = 56;
+
+    if (!_PyArg_CheckPositional("unsigned_long_long_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedLongLong_Converter(args[0], &a)) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!_PyLong_UnsignedLongLong_Converter(args[1], &b)) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (!PyLong_Check(args[2])) {
+        _PyArg_BadArgument("unsigned_long_long_converter", "argument 3", "int", args[2]);
+        goto exit;
+    }
+    c = PyLong_AsUnsignedLongLongMask(args[2]);
+skip_optional:
+    return_value = unsigned_long_long_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(py_ssize_t_converter__doc__,
+"py_ssize_t_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define PY_SSIZE_T_CONVERTER_METHODDEF    \
+    {"py_ssize_t_converter", _PyCFunction_CAST(py_ssize_t_converter), METH_FASTCALL, py_ssize_t_converter__doc__},
+
+static PyObject *
+py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
+                          Py_ssize_t c);
+
+static PyObject *
+py_ssize_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t a = 12;
+    Py_ssize_t b = 34;
+    Py_ssize_t c = 56;
+
+    if (!_PyArg_CheckPositional("py_ssize_t_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    {
+        Py_ssize_t ival = -1;
+        PyObject *iobj = _PyNumber_Index(args[0]);
+        if (iobj != NULL) {
+            ival = PyLong_AsSsize_t(iobj);
+            Py_DECREF(iobj);
+        }
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        a = ival;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    {
+        Py_ssize_t ival = -1;
+        PyObject *iobj = _PyNumber_Index(args[1]);
+        if (iobj != NULL) {
+            ival = PyLong_AsSsize_t(iobj);
+            Py_DECREF(iobj);
+        }
+        if (ival == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        b = ival;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (!_Py_convert_optional_to_ssize_t(args[2], &c)) {
+        goto exit;
+    }
+skip_optional:
+    return_value = py_ssize_t_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(slice_index_converter__doc__,
+"slice_index_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define SLICE_INDEX_CONVERTER_METHODDEF    \
+    {"slice_index_converter", _PyCFunction_CAST(slice_index_converter), METH_FASTCALL, slice_index_converter__doc__},
+
+static PyObject *
+slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
+                           Py_ssize_t c);
+
+static PyObject *
+slice_index_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t a = 12;
+    Py_ssize_t b = 34;
+    Py_ssize_t c = 56;
+
+    if (!_PyArg_CheckPositional("slice_index_converter", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (!_PyEval_SliceIndex(args[0], &a)) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!_PyEval_SliceIndexNotNone(args[1], &b)) {
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (!_PyEval_SliceIndex(args[2], &c)) {
+        goto exit;
+    }
+skip_optional:
+    return_value = slice_index_converter_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(size_t_converter__doc__,
+"size_t_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define SIZE_T_CONVERTER_METHODDEF    \
+    {"size_t_converter", _PyCFunction_CAST(size_t_converter), METH_FASTCALL, size_t_converter__doc__},
+
+static PyObject *
+size_t_converter_impl(PyObject *module, size_t a);
+
+static PyObject *
+size_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    size_t a = 12;
+
+    if (!_PyArg_CheckPositional("size_t_converter", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (!_PyLong_Size_t_Converter(args[0], &a)) {
+        goto exit;
+    }
+skip_optional:
+    return_value = size_t_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(float_converter__doc__,
+"float_converter($module, a=12.5, /)\n"
+"--\n"
+"\n");
+
+#define FLOAT_CONVERTER_METHODDEF    \
+    {"float_converter", _PyCFunction_CAST(float_converter), METH_FASTCALL, float_converter__doc__},
+
+static PyObject *
+float_converter_impl(PyObject *module, float a);
+
+static PyObject *
+float_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    float a = 12.5;
+
+    if (!_PyArg_CheckPositional("float_converter", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (PyFloat_CheckExact(args[0])) {
+        a = (float) (PyFloat_AS_DOUBLE(args[0]));
+    }
+    else
+    {
+        a = (float) PyFloat_AsDouble(args[0]);
+        if (a == -1.0 && PyErr_Occurred()) {
+            goto exit;
+        }
+    }
+skip_optional:
+    return_value = float_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(double_converter__doc__,
+"double_converter($module, a=12.5, /)\n"
+"--\n"
+"\n");
+
+#define DOUBLE_CONVERTER_METHODDEF    \
+    {"double_converter", _PyCFunction_CAST(double_converter), METH_FASTCALL, double_converter__doc__},
+
+static PyObject *
+double_converter_impl(PyObject *module, double a);
+
+static PyObject *
+double_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    double a = 12.5;
+
+    if (!_PyArg_CheckPositional("double_converter", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (PyFloat_CheckExact(args[0])) {
+        a = PyFloat_AS_DOUBLE(args[0]);
+    }
+    else
+    {
+        a = PyFloat_AsDouble(args[0]);
+        if (a == -1.0 && PyErr_Occurred()) {
+            goto exit;
+        }
+    }
+skip_optional:
+    return_value = double_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(py_complex_converter__doc__,
+"py_complex_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define PY_COMPLEX_CONVERTER_METHODDEF    \
+    {"py_complex_converter", (PyCFunction)py_complex_converter, METH_O, py_complex_converter__doc__},
+
+static PyObject *
+py_complex_converter_impl(PyObject *module, Py_complex a);
+
+static PyObject *
+py_complex_converter(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    Py_complex a;
+
+    a = PyComplex_AsCComplex(arg);
+    if (PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = py_complex_converter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(str_converter__doc__,
+"str_converter($module, a=\'a\', b=\'b\', c=\'c\', /)\n"
+"--\n"
+"\n");
+
+#define STR_CONVERTER_METHODDEF    \
+    {"str_converter", _PyCFunction_CAST(str_converter), METH_FASTCALL, str_converter__doc__},
+
+static PyObject *
+str_converter_impl(PyObject *module, const char *a, const char *b,
+                   const char *c, Py_ssize_t c_length);
+
+static PyObject *
+str_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    const char *a = "a";
+    const char *b = "b";
+    const char *c = "c";
+    Py_ssize_t c_length;
+
+    if (!_PyArg_ParseStack(args, nargs, "|sys#:str_converter",
+        &a, &b, &c, &c_length)) {
+        goto exit;
+    }
+    return_value = str_converter_impl(module, a, b, c, c_length);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(str_converter_encoding__doc__,
+"str_converter_encoding($module, a, b, c, /)\n"
+"--\n"
+"\n");
+
+#define STR_CONVERTER_ENCODING_METHODDEF    \
+    {"str_converter_encoding", _PyCFunction_CAST(str_converter_encoding), METH_FASTCALL, str_converter_encoding__doc__},
+
+static PyObject *
+str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c,
+                            Py_ssize_t c_length);
+
+static PyObject *
+str_converter_encoding(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    char *a = NULL;
+    char *b = NULL;
+    char *c = NULL;
+    Py_ssize_t c_length;
+
+    if (!_PyArg_ParseStack(args, nargs, "esetet#:str_converter_encoding",
+        "idna", &a, "idna", &b, "idna", &c, &c_length)) {
+        goto exit;
+    }
+    return_value = str_converter_encoding_impl(module, a, b, c, c_length);
+    /* Post parse cleanup for a */
+    PyMem_FREE(a);
+    /* Post parse cleanup for b */
+    PyMem_FREE(b);
+    /* Post parse cleanup for c */
+    PyMem_FREE(c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(py_buffer_converter__doc__,
+"py_buffer_converter($module, a, b, /)\n"
+"--\n"
+"\n");
+
+#define PY_BUFFER_CONVERTER_METHODDEF    \
+    {"py_buffer_converter", _PyCFunction_CAST(py_buffer_converter), METH_FASTCALL, py_buffer_converter__doc__},
+
+static PyObject *
+py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b);
+
+static PyObject *
+py_buffer_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    Py_buffer a = {NULL, NULL};
+    Py_buffer b = {NULL, NULL};
+
+    if (!_PyArg_ParseStack(args, nargs, "z*w*:py_buffer_converter",
+        &a, &b)) {
+        goto exit;
+    }
+    return_value = py_buffer_converter_impl(module, &a, &b);
+
+exit:
+    /* Cleanup for a */
+    if (a.obj) {
+       PyBuffer_Release(&a);
+    }
+    /* Cleanup for b */
+    if (b.obj) {
+       PyBuffer_Release(&b);
+    }
+
+    return return_value;
+}
+
+PyDoc_STRVAR(keywords__doc__,
+"keywords($module, /, a, b)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_METHODDEF    \
+    {"keywords", _PyCFunction_CAST(keywords), METH_FASTCALL|METH_KEYWORDS, keywords__doc__},
+
+static PyObject *
+keywords_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+keywords(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), },
+    };
+    #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[] = {"a", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "keywords",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    PyObject *a;
+    PyObject *b;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    return_value = keywords_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(keywords_kwonly__doc__,
+"keywords_kwonly($module, /, a, *, b)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_KWONLY_METHODDEF    \
+    {"keywords_kwonly", _PyCFunction_CAST(keywords_kwonly), METH_FASTCALL|METH_KEYWORDS, keywords_kwonly__doc__},
+
+static PyObject *
+keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+keywords_kwonly(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), },
+    };
+    #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[] = {"a", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "keywords_kwonly",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    PyObject *a;
+    PyObject *b;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    return_value = keywords_kwonly_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(keywords_opt__doc__,
+"keywords_opt($module, /, a, b=None, c=None)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_OPT_METHODDEF    \
+    {"keywords_opt", _PyCFunction_CAST(keywords_opt), METH_FASTCALL|METH_KEYWORDS, keywords_opt__doc__},
+
+static PyObject *
+keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c);
+
+static PyObject *
+keywords_opt(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), },
+    };
+    #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[] = {"a", "b", "c", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "keywords_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[1]) {
+        b = args[1];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    c = args[2];
+skip_optional_pos:
+    return_value = keywords_opt_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(keywords_opt_kwonly__doc__,
+"keywords_opt_kwonly($module, /, a, b=None, *, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_OPT_KWONLY_METHODDEF    \
+    {"keywords_opt_kwonly", _PyCFunction_CAST(keywords_opt_kwonly), METH_FASTCALL|METH_KEYWORDS, keywords_opt_kwonly__doc__},
+
+static PyObject *
+keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
+                         PyObject *c, PyObject *d);
+
+static PyObject *
+keywords_opt_kwonly(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 4
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), },
+    };
+    #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[] = {"a", "b", "c", "d", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "keywords_opt_kwonly",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[1]) {
+        b = args[1];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    d = args[3];
+skip_optional_kwonly:
+    return_value = keywords_opt_kwonly_impl(module, a, b, c, d);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(keywords_kwonly_opt__doc__,
+"keywords_kwonly_opt($module, /, a, *, b=None, c=None)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_KWONLY_OPT_METHODDEF    \
+    {"keywords_kwonly_opt", _PyCFunction_CAST(keywords_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, keywords_kwonly_opt__doc__},
+
+static PyObject *
+keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+                         PyObject *c);
+
+static PyObject *
+keywords_kwonly_opt(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), },
+    };
+    #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[] = {"a", "b", "c", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "keywords_kwonly_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[1]) {
+        b = args[1];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    c = args[2];
+skip_optional_kwonly:
+    return_value = keywords_kwonly_opt_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords__doc__,
+"posonly_keywords($module, a, /, b)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_METHODDEF    \
+    {"posonly_keywords", _PyCFunction_CAST(posonly_keywords), METH_FASTCALL|METH_KEYWORDS, posonly_keywords__doc__},
+
+static PyObject *
+posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+posonly_keywords(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), },
+    };
+    #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[] = {"", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_keywords",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    PyObject *a;
+    PyObject *b;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    return_value = posonly_keywords_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_kwonly__doc__,
+"posonly_kwonly($module, a, /, *, b)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KWONLY_METHODDEF    \
+    {"posonly_kwonly", _PyCFunction_CAST(posonly_kwonly), METH_FASTCALL|METH_KEYWORDS, posonly_kwonly__doc__},
+
+static PyObject *
+posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+posonly_kwonly(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), },
+    };
+    #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[] = {"", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_kwonly",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    PyObject *a;
+    PyObject *b;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    return_value = posonly_kwonly_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_kwonly__doc__,
+"posonly_keywords_kwonly($module, a, /, b, *, c)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_KWONLY_METHODDEF    \
+    {"posonly_keywords_kwonly", _PyCFunction_CAST(posonly_keywords_kwonly), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_kwonly__doc__},
+
+static PyObject *
+posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
+                             PyObject *c);
+
+static PyObject *
+posonly_keywords_kwonly(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), &_Py_ID(c), },
+    };
+    #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[] = {"", "b", "c", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_keywords_kwonly",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    PyObject *a;
+    PyObject *b;
+    PyObject *c;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    c = args[2];
+    return_value = posonly_keywords_kwonly_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_opt__doc__,
+"posonly_keywords_opt($module, a, /, b, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_OPT_METHODDEF    \
+    {"posonly_keywords_opt", _PyCFunction_CAST(posonly_keywords_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_opt__doc__},
+
+static PyObject *
+posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+                          PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_keywords_opt(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), },
+    };
+    #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[] = {"", "b", "c", "d", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_keywords_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+    PyObject *a;
+    PyObject *b;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 4, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    d = args[3];
+skip_optional_pos:
+    return_value = posonly_keywords_opt_impl(module, a, b, c, d);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_opt_keywords_opt__doc__,
+"posonly_opt_keywords_opt($module, a, b=None, /, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_OPT_KEYWORDS_OPT_METHODDEF    \
+    {"posonly_opt_keywords_opt", _PyCFunction_CAST(posonly_opt_keywords_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_keywords_opt__doc__},
+
+static PyObject *
+posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+                              PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_opt_keywords_opt(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(c), &_Py_ID(d), },
+    };
+    #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[] = {"", "", "c", "d", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_opt_keywords_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    if (nargs < 2) {
+        goto skip_optional_posonly;
+    }
+    noptargs--;
+    b = args[1];
+skip_optional_posonly:
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    d = args[3];
+skip_optional_pos:
+    return_value = posonly_opt_keywords_opt_impl(module, a, b, c, d);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_kwonly_opt__doc__,
+"posonly_kwonly_opt($module, a, /, *, b, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KWONLY_OPT_METHODDEF    \
+    {"posonly_kwonly_opt", _PyCFunction_CAST(posonly_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_kwonly_opt__doc__},
+
+static PyObject *
+posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+                        PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_kwonly_opt(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), },
+    };
+    #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[] = {"", "b", "c", "d", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_kwonly_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+    PyObject *a;
+    PyObject *b;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    d = args[3];
+skip_optional_kwonly:
+    return_value = posonly_kwonly_opt_impl(module, a, b, c, d);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_opt_kwonly_opt__doc__,
+"posonly_opt_kwonly_opt($module, a, b=None, /, *, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_OPT_KWONLY_OPT_METHODDEF    \
+    {"posonly_opt_kwonly_opt", _PyCFunction_CAST(posonly_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_kwonly_opt__doc__},
+
+static PyObject *
+posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+                            PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_opt_kwonly_opt(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(c), &_Py_ID(d), },
+    };
+    #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[] = {"", "", "c", "d", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_opt_kwonly_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    if (nargs < 2) {
+        goto skip_optional_posonly;
+    }
+    noptargs--;
+    b = args[1];
+skip_optional_posonly:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    d = args[3];
+skip_optional_kwonly:
+    return_value = posonly_opt_kwonly_opt_impl(module, a, b, c, d);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_kwonly_opt__doc__,
+"posonly_keywords_kwonly_opt($module, a, /, b, *, c, d=None, e=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_KWONLY_OPT_METHODDEF    \
+    {"posonly_keywords_kwonly_opt", _PyCFunction_CAST(posonly_keywords_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_kwonly_opt__doc__},
+
+static PyObject *
+posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+                                 PyObject *c, PyObject *d, PyObject *e);
+
+static PyObject *
+posonly_keywords_kwonly_opt(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 4
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), &_Py_ID(e), },
+    };
+    #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[] = {"", "b", "c", "d", "e", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_keywords_kwonly_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[5];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
+    PyObject *a;
+    PyObject *b;
+    PyObject *c;
+    PyObject *d = Py_None;
+    PyObject *e = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    c = args[2];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[3]) {
+        d = args[3];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    e = args[4];
+skip_optional_kwonly:
+    return_value = posonly_keywords_kwonly_opt_impl(module, a, b, c, d, e);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_opt_kwonly_opt__doc__,
+"posonly_keywords_opt_kwonly_opt($module, a, /, b, c=None, *, d=None,\n"
+"                                e=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_OPT_KWONLY_OPT_METHODDEF    \
+    {"posonly_keywords_opt_kwonly_opt", _PyCFunction_CAST(posonly_keywords_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_opt_kwonly_opt__doc__},
+
+static PyObject *
+posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
+                                     PyObject *b, PyObject *c, PyObject *d,
+                                     PyObject *e);
+
+static PyObject *
+posonly_keywords_opt_kwonly_opt(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 4
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), &_Py_ID(e), },
+    };
+    #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[] = {"", "b", "c", "d", "e", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_keywords_opt_kwonly_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[5];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+    PyObject *a;
+    PyObject *b;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+    PyObject *e = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[3]) {
+        d = args[3];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    e = args[4];
+skip_optional_kwonly:
+    return_value = posonly_keywords_opt_kwonly_opt_impl(module, a, b, c, d, e);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_opt_keywords_opt_kwonly_opt__doc__,
+"posonly_opt_keywords_opt_kwonly_opt($module, a, b=None, /, c=None, *,\n"
+"                                    d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_OPT_KEYWORDS_OPT_KWONLY_OPT_METHODDEF    \
+    {"posonly_opt_keywords_opt_kwonly_opt", _PyCFunction_CAST(posonly_opt_keywords_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_keywords_opt_kwonly_opt__doc__},
+
+static PyObject *
+posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
+                                         PyObject *b, PyObject *c,
+                                         PyObject *d);
+
+static PyObject *
+posonly_opt_keywords_opt_kwonly_opt(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(c), &_Py_ID(d), },
+    };
+    #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[] = {"", "", "c", "d", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_opt_keywords_opt_kwonly_opt",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+    PyObject *d = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    if (nargs < 2) {
+        goto skip_optional_posonly;
+    }
+    noptargs--;
+    b = args[1];
+skip_optional_posonly:
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[2]) {
+        c = args[2];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    d = args[3];
+skip_optional_kwonly:
+    return_value = posonly_opt_keywords_opt_kwonly_opt_impl(module, a, b, c, d);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(keyword_only_parameter__doc__,
+"keyword_only_parameter($module, /, *, a)\n"
+"--\n"
+"\n");
+
+#define KEYWORD_ONLY_PARAMETER_METHODDEF    \
+    {"keyword_only_parameter", _PyCFunction_CAST(keyword_only_parameter), METH_FASTCALL|METH_KEYWORDS, keyword_only_parameter__doc__},
+
+static PyObject *
+keyword_only_parameter_impl(PyObject *module, PyObject *a);
+
+static PyObject *
+keyword_only_parameter(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), },
+    };
+    #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[] = {"a", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "keyword_only_parameter",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject *a;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    return_value = keyword_only_parameter_impl(module, a);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(posonly_vararg__doc__,
+"posonly_vararg($module, a, /, b, *args)\n"
+"--\n"
+"\n");
+
+#define POSONLY_VARARG_METHODDEF    \
+    {"posonly_vararg", _PyCFunction_CAST(posonly_vararg), METH_FASTCALL|METH_KEYWORDS, posonly_vararg__doc__},
+
+static PyObject *
+posonly_vararg_impl(PyObject *module, PyObject *a, PyObject *b,
+                    PyObject *args);
+
+static PyObject *
+posonly_vararg(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), },
+    };
+    #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[] = {"", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "posonly_vararg",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    PyObject *a;
+    PyObject *b;
+    PyObject *__clinic_args = NULL;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, 2, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    b = args[1];
+    __clinic_args = args[2];
+    return_value = posonly_vararg_impl(module, a, b, __clinic_args);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(vararg_and_posonly__doc__,
+"vararg_and_posonly($module, a, /, *args)\n"
+"--\n"
+"\n");
+
+#define VARARG_AND_POSONLY_METHODDEF    \
+    {"vararg_and_posonly", _PyCFunction_CAST(vararg_and_posonly), METH_FASTCALL, vararg_and_posonly__doc__},
+
+static PyObject *
+vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args);
+
+static PyObject *
+vararg_and_posonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *__clinic_args = NULL;
+
+    if (!_PyArg_CheckPositional("vararg_and_posonly", nargs, 1, PY_SSIZE_T_MAX)) {
+        goto exit;
+    }
+    a = args[0];
+    __clinic_args = PyTuple_New(nargs - 1);
+    if (!__clinic_args) {
+        goto exit;
+    }
+    for (Py_ssize_t i = 0; i < nargs - 1; ++i) {
+        PyTuple_SET_ITEM(__clinic_args, i, Py_NewRef(args[1 + i]));
+    }
+    return_value = vararg_and_posonly_impl(module, a, __clinic_args);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(vararg__doc__,
+"vararg($module, /, a, *args)\n"
+"--\n"
+"\n");
+
+#define VARARG_METHODDEF    \
+    {"vararg", _PyCFunction_CAST(vararg), METH_FASTCALL|METH_KEYWORDS, vararg__doc__},
+
+static PyObject *
+vararg_impl(PyObject *module, PyObject *a, PyObject *args);
+
+static PyObject *
+vararg(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), },
+    };
+    #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[] = {"a", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "vararg",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    PyObject *a;
+    PyObject *__clinic_args = NULL;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    __clinic_args = args[1];
+    return_value = vararg_impl(module, a, __clinic_args);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(vararg_with_default__doc__,
+"vararg_with_default($module, /, a, *args, b=False)\n"
+"--\n"
+"\n");
+
+#define VARARG_WITH_DEFAULT_METHODDEF    \
+    {"vararg_with_default", _PyCFunction_CAST(vararg_with_default), METH_FASTCALL|METH_KEYWORDS, vararg_with_default__doc__},
+
+static PyObject *
+vararg_with_default_impl(PyObject *module, PyObject *a, PyObject *args,
+                         int b);
+
+static PyObject *
+vararg_with_default(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), },
+    };
+    #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[] = {"a", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "vararg_with_default",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *__clinic_args = NULL;
+    int b = 0;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    __clinic_args = args[1];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    b = PyObject_IsTrue(args[2]);
+    if (b < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = vararg_with_default_impl(module, a, __clinic_args, b);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(vararg_with_default2__doc__,
+"vararg_with_default2($module, /, a, *args, b=None, c=None)\n"
+"--\n"
+"\n");
+
+#define VARARG_WITH_DEFAULT2_METHODDEF    \
+    {"vararg_with_default2", _PyCFunction_CAST(vararg_with_default2), METH_FASTCALL|METH_KEYWORDS, vararg_with_default2__doc__},
+
+static PyObject *
+vararg_with_default2_impl(PyObject *module, PyObject *a, PyObject *args,
+                          PyObject *b, PyObject *c);
+
+static PyObject *
+vararg_with_default2(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), },
+    };
+    #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[] = {"a", "b", "c", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "vararg_with_default2",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *a;
+    PyObject *__clinic_args = NULL;
+    PyObject *b = Py_None;
+    PyObject *c = Py_None;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    a = args[0];
+    __clinic_args = args[1];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[2]) {
+        b = args[2];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    c = args[3];
+skip_optional_kwonly:
+    return_value = vararg_with_default2_impl(module, a, __clinic_args, b, c);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(vararg_with_only_defaults__doc__,
+"vararg_with_only_defaults($module, /, *args, b=None)\n"
+"--\n"
+"\n");
+
+#define VARARG_WITH_ONLY_DEFAULTS_METHODDEF    \
+    {"vararg_with_only_defaults", _PyCFunction_CAST(vararg_with_only_defaults), METH_FASTCALL|METH_KEYWORDS, vararg_with_only_defaults__doc__},
+
+static PyObject *
+vararg_with_only_defaults_impl(PyObject *module, PyObject *args, PyObject *b);
+
+static PyObject *
+vararg_with_only_defaults(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(b), },
+    };
+    #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[] = {"b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "vararg_with_only_defaults",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *__clinic_args = NULL;
+    PyObject *b = Py_None;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    __clinic_args = args[0];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    b = args[1];
+skip_optional_kwonly:
+    return_value = vararg_with_only_defaults_impl(module, __clinic_args, b);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(gh_32092_oob__doc__,
+"gh_32092_oob($module, /, pos1, pos2, *varargs, kw1=None, kw2=None)\n"
+"--\n"
+"\n"
+"Proof-of-concept of GH-32092 OOB bug.");
+
+#define GH_32092_OOB_METHODDEF    \
+    {"gh_32092_oob", _PyCFunction_CAST(gh_32092_oob), METH_FASTCALL|METH_KEYWORDS, gh_32092_oob__doc__},
+
+static PyObject *
+gh_32092_oob_impl(PyObject *module, PyObject *pos1, PyObject *pos2,
+                  PyObject *varargs, PyObject *kw1, PyObject *kw2);
+
+static PyObject *
+gh_32092_oob(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 4
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(pos1), &_Py_ID(pos2), &_Py_ID(kw1), &_Py_ID(kw2), },
+    };
+    #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[] = {"pos1", "pos2", "kw1", "kw2", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "gh_32092_oob",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[5];
+    Py_ssize_t noptargs = Py_MIN(nargs, 2) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+    PyObject *pos1;
+    PyObject *pos2;
+    PyObject *varargs = NULL;
+    PyObject *kw1 = Py_None;
+    PyObject *kw2 = Py_None;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, 2, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    pos1 = args[0];
+    pos2 = args[1];
+    varargs = args[2];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    if (args[3]) {
+        kw1 = args[3];
+        if (!--noptargs) {
+            goto skip_optional_kwonly;
+        }
+    }
+    kw2 = args[4];
+skip_optional_kwonly:
+    return_value = gh_32092_oob_impl(module, pos1, pos2, varargs, kw1, kw2);
+
+exit:
+    Py_XDECREF(varargs);
+    return return_value;
+}
+
+PyDoc_STRVAR(gh_32092_kw_pass__doc__,
+"gh_32092_kw_pass($module, /, pos, *args, kw=None)\n"
+"--\n"
+"\n"
+"Proof-of-concept of GH-32092 keyword args passing bug.");
+
+#define GH_32092_KW_PASS_METHODDEF    \
+    {"gh_32092_kw_pass", _PyCFunction_CAST(gh_32092_kw_pass), METH_FASTCALL|METH_KEYWORDS, gh_32092_kw_pass__doc__},
+
+static PyObject *
+gh_32092_kw_pass_impl(PyObject *module, PyObject *pos, PyObject *args,
+                      PyObject *kw);
+
+static PyObject *
+gh_32092_kw_pass(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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(pos), &_Py_ID(kw), },
+    };
+    #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[] = {"pos", "kw", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "gh_32092_kw_pass",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    PyObject *pos;
+    PyObject *__clinic_args = NULL;
+    PyObject *kw = Py_None;
+
+    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    pos = args[0];
+    __clinic_args = args[1];
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    kw = args[2];
+skip_optional_kwonly:
+    return_value = gh_32092_kw_pass_impl(module, pos, __clinic_args, kw);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(gh_99233_refcount__doc__,
+"gh_99233_refcount($module, /, *args)\n"
+"--\n"
+"\n"
+"Proof-of-concept of GH-99233 refcount error bug.");
+
+#define GH_99233_REFCOUNT_METHODDEF    \
+    {"gh_99233_refcount", _PyCFunction_CAST(gh_99233_refcount), METH_FASTCALL, gh_99233_refcount__doc__},
+
+static PyObject *
+gh_99233_refcount_impl(PyObject *module, PyObject *args);
+
+static PyObject *
+gh_99233_refcount(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *__clinic_args = NULL;
+
+    if (!_PyArg_CheckPositional("gh_99233_refcount", nargs, 0, PY_SSIZE_T_MAX)) {
+        goto exit;
+    }
+    __clinic_args = PyTuple_New(nargs - 0);
+    if (!__clinic_args) {
+        goto exit;
+    }
+    for (Py_ssize_t i = 0; i < nargs - 0; ++i) {
+        PyTuple_SET_ITEM(__clinic_args, i, Py_NewRef(args[0 + i]));
+    }
+    return_value = gh_99233_refcount_impl(module, __clinic_args);
+
+exit:
+    Py_XDECREF(__clinic_args);
+    return return_value;
+}
+
+PyDoc_STRVAR(gh_99240_double_free__doc__,
+"gh_99240_double_free($module, a, b, /)\n"
+"--\n"
+"\n"
+"Proof-of-concept of GH-99240 double-free bug.");
+
+#define GH_99240_DOUBLE_FREE_METHODDEF    \
+    {"gh_99240_double_free", _PyCFunction_CAST(gh_99240_double_free), METH_FASTCALL, gh_99240_double_free__doc__},
+
+static PyObject *
+gh_99240_double_free_impl(PyObject *module, char *a, char *b);
+
+static PyObject *
+gh_99240_double_free(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    char *a = NULL;
+    char *b = NULL;
+
+    if (!_PyArg_ParseStack(args, nargs, "eses:gh_99240_double_free",
+        "idna", &a, "idna", &b)) {
+        goto exit;
+    }
+    return_value = gh_99240_double_free_impl(module, a, b);
+    /* Post parse cleanup for a */
+    PyMem_FREE(a);
+    /* Post parse cleanup for b */
+    PyMem_FREE(b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(clone_f1__doc__,
+"clone_f1($module, /, path)\n"
+"--\n"
+"\n");
+
+#define CLONE_F1_METHODDEF    \
+    {"clone_f1", _PyCFunction_CAST(clone_f1), METH_FASTCALL|METH_KEYWORDS, clone_f1__doc__},
+
+static PyObject *
+clone_f1_impl(PyObject *module, const char *path);
+
+static PyObject *
+clone_f1(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(path), },
+    };
+    #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[] = {"path", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "clone_f1",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    const char *path;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!PyUnicode_Check(args[0])) {
+        _PyArg_BadArgument("clone_f1", "argument 'path'", "str", args[0]);
+        goto exit;
+    }
+    Py_ssize_t path_length;
+    path = PyUnicode_AsUTF8AndSize(args[0], &path_length);
+    if (path == NULL) {
+        goto exit;
+    }
+    if (strlen(path) != (size_t)path_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = clone_f1_impl(module, path);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(clone_f2__doc__,
+"clone_f2($module, /, path)\n"
+"--\n"
+"\n");
+
+#define CLONE_F2_METHODDEF    \
+    {"clone_f2", _PyCFunction_CAST(clone_f2), METH_FASTCALL|METH_KEYWORDS, clone_f2__doc__},
+
+static PyObject *
+clone_f2_impl(PyObject *module, const char *path);
+
+static PyObject *
+clone_f2(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(path), },
+    };
+    #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[] = {"path", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "clone_f2",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    const char *path;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!PyUnicode_Check(args[0])) {
+        _PyArg_BadArgument("clone_f2", "argument 'path'", "str", args[0]);
+        goto exit;
+    }
+    Py_ssize_t path_length;
+    path = PyUnicode_AsUTF8AndSize(args[0], &path_length);
+    if (path == NULL) {
+        goto exit;
+    }
+    if (strlen(path) != (size_t)path_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = clone_f2_impl(module, path);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(clone_with_conv_f1__doc__,
+"clone_with_conv_f1($module, /, path=None)\n"
+"--\n"
+"\n");
+
+#define CLONE_WITH_CONV_F1_METHODDEF    \
+    {"clone_with_conv_f1", _PyCFunction_CAST(clone_with_conv_f1), METH_FASTCALL|METH_KEYWORDS, clone_with_conv_f1__doc__},
+
+static PyObject *
+clone_with_conv_f1_impl(PyObject *module, custom_t path);
+
+static PyObject *
+clone_with_conv_f1(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(path), },
+    };
+    #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[] = {"path", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "clone_with_conv_f1",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    custom_t path = {
+                .name = "clone_with_conv_f1",
+            };
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (!custom_converter(args[0], &path)) {
+        goto exit;
+    }
+skip_optional_pos:
+    return_value = clone_with_conv_f1_impl(module, path);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(clone_with_conv_f2__doc__,
+"clone_with_conv_f2($module, /, path=None)\n"
+"--\n"
+"\n");
+
+#define CLONE_WITH_CONV_F2_METHODDEF    \
+    {"clone_with_conv_f2", _PyCFunction_CAST(clone_with_conv_f2), METH_FASTCALL|METH_KEYWORDS, clone_with_conv_f2__doc__},
+
+static PyObject *
+clone_with_conv_f2_impl(PyObject *module, custom_t path);
+
+static PyObject *
+clone_with_conv_f2(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(path), },
+    };
+    #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[] = {"path", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "clone_with_conv_f2",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    custom_t path = {
+                .name = "clone_with_conv_f2",
+            };
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (!custom_converter(args[0], &path)) {
+        goto exit;
+    }
+skip_optional_pos:
+    return_value = clone_with_conv_f2_impl(module, path);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_testclinic_TestClass_meth_method_no_params__doc__,
+"meth_method_no_params($self, /)\n"
+"--\n"
+"\n");
+
+#define _TESTCLINIC_TESTCLASS_METH_METHOD_NO_PARAMS_METHODDEF    \
+    {"meth_method_no_params", _PyCFunction_CAST(_testclinic_TestClass_meth_method_no_params), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _testclinic_TestClass_meth_method_no_params__doc__},
+
+static PyObject *
+_testclinic_TestClass_meth_method_no_params_impl(PyObject *self,
+                                                 PyTypeObject *cls);
+
+static PyObject *
+_testclinic_TestClass_meth_method_no_params(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "meth_method_no_params() takes no arguments");
+        return NULL;
+    }
+    return _testclinic_TestClass_meth_method_no_params_impl(self, cls);
+}
+/*[clinic end generated code: output=d1fcf6ab8867f4ad input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_testinternalcapi.c.h b/contrib/tools/python3/Modules/clinic/_testinternalcapi.c.h
new file mode 100644
index 00000000000..1cc4ad4c16c
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_testinternalcapi.c.h
@@ -0,0 +1,269 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_testinternalcapi_compiler_codegen__doc__,
+"compiler_codegen($module, /, ast, filename, optimize, compile_mode=0)\n"
+"--\n"
+"\n"
+"Apply compiler code generation to an AST.");
+
+#define _TESTINTERNALCAPI_COMPILER_CODEGEN_METHODDEF    \
+    {"compiler_codegen", _PyCFunction_CAST(_testinternalcapi_compiler_codegen), METH_FASTCALL|METH_KEYWORDS, _testinternalcapi_compiler_codegen__doc__},
+
+static PyObject *
+_testinternalcapi_compiler_codegen_impl(PyObject *module, PyObject *ast,
+                                        PyObject *filename, int optimize,
+                                        int compile_mode);
+
+static PyObject *
+_testinternalcapi_compiler_codegen(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 4
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(ast), &_Py_ID(filename), &_Py_ID(optimize), &_Py_ID(compile_mode), },
+    };
+    #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[] = {"ast", "filename", "optimize", "compile_mode", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "compiler_codegen",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[4];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
+    PyObject *ast;
+    PyObject *filename;
+    int optimize;
+    int compile_mode = 0;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 4, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    ast = args[0];
+    filename = args[1];
+    optimize = _PyLong_AsInt(args[2]);
+    if (optimize == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    compile_mode = _PyLong_AsInt(args[3]);
+    if (compile_mode == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional_pos:
+    return_value = _testinternalcapi_compiler_codegen_impl(module, ast, filename, optimize, compile_mode);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_testinternalcapi_optimize_cfg__doc__,
+"optimize_cfg($module, /, instructions, consts, nlocals)\n"
+"--\n"
+"\n"
+"Apply compiler optimizations to an instruction list.");
+
+#define _TESTINTERNALCAPI_OPTIMIZE_CFG_METHODDEF    \
+    {"optimize_cfg", _PyCFunction_CAST(_testinternalcapi_optimize_cfg), METH_FASTCALL|METH_KEYWORDS, _testinternalcapi_optimize_cfg__doc__},
+
+static PyObject *
+_testinternalcapi_optimize_cfg_impl(PyObject *module, PyObject *instructions,
+                                    PyObject *consts, int nlocals);
+
+static PyObject *
+_testinternalcapi_optimize_cfg(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(instructions), &_Py_ID(consts), &_Py_ID(nlocals), },
+    };
+    #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[] = {"instructions", "consts", "nlocals", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "optimize_cfg",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    PyObject *instructions;
+    PyObject *consts;
+    int nlocals;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    instructions = args[0];
+    consts = args[1];
+    nlocals = _PyLong_AsInt(args[2]);
+    if (nlocals == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _testinternalcapi_optimize_cfg_impl(module, instructions, consts, nlocals);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_testinternalcapi_assemble_code_object__doc__,
+"assemble_code_object($module, /, filename, instructions, metadata)\n"
+"--\n"
+"\n"
+"Create a code object for the given instructions.");
+
+#define _TESTINTERNALCAPI_ASSEMBLE_CODE_OBJECT_METHODDEF    \
+    {"assemble_code_object", _PyCFunction_CAST(_testinternalcapi_assemble_code_object), METH_FASTCALL|METH_KEYWORDS, _testinternalcapi_assemble_code_object__doc__},
+
+static PyObject *
+_testinternalcapi_assemble_code_object_impl(PyObject *module,
+                                            PyObject *filename,
+                                            PyObject *instructions,
+                                            PyObject *metadata);
+
+static PyObject *
+_testinternalcapi_assemble_code_object(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 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(filename), &_Py_ID(instructions), &_Py_ID(metadata), },
+    };
+    #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[] = {"filename", "instructions", "metadata", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "assemble_code_object",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    PyObject *filename;
+    PyObject *instructions;
+    PyObject *metadata;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    filename = args[0];
+    instructions = args[1];
+    metadata = args[2];
+    return_value = _testinternalcapi_assemble_code_object_impl(module, filename, instructions, metadata);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(gh_119213_getargs__doc__,
+"gh_119213_getargs($module, /, spam=None)\n"
+"--\n"
+"\n"
+"Test _PyArg_Parser.kwtuple");
+
+#define GH_119213_GETARGS_METHODDEF    \
+    {"gh_119213_getargs", _PyCFunction_CAST(gh_119213_getargs), METH_FASTCALL|METH_KEYWORDS, gh_119213_getargs__doc__},
+
+static PyObject *
+gh_119213_getargs_impl(PyObject *module, PyObject *spam);
+
+static PyObject *
+gh_119213_getargs(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
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(spam), },
+    };
+    #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[] = {"spam", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "gh_119213_getargs",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *spam = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    spam = args[0];
+skip_optional_pos:
+    return_value = gh_119213_getargs_impl(module, spam);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=1fa5cb831dbb391f input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_testmultiphase.c.h b/contrib/tools/python3/Modules/clinic/_testmultiphase.c.h
new file mode 100644
index 00000000000..4f2b1bcf98b
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_testmultiphase.c.h
@@ -0,0 +1,165 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_testmultiphase_StateAccessType_get_defining_module__doc__,
+"get_defining_module($self, /)\n"
+"--\n"
+"\n"
+"Return the module of the defining class.\n"
+"\n"
+"Also tests that result of PyType_GetModuleByDef matches defining_class\'s\n"
+"module.");
+
+#define _TESTMULTIPHASE_STATEACCESSTYPE_GET_DEFINING_MODULE_METHODDEF    \
+    {"get_defining_module", _PyCFunction_CAST(_testmultiphase_StateAccessType_get_defining_module), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _testmultiphase_StateAccessType_get_defining_module__doc__},
+
+static PyObject *
+_testmultiphase_StateAccessType_get_defining_module_impl(StateAccessTypeObject *self,
+                                                         PyTypeObject *cls);
+
+static PyObject *
+_testmultiphase_StateAccessType_get_defining_module(StateAccessTypeObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "get_defining_module() takes no arguments");
+        return NULL;
+    }
+    return _testmultiphase_StateAccessType_get_defining_module_impl(self, cls);
+}
+
+PyDoc_STRVAR(_testmultiphase_StateAccessType_getmodulebydef_bad_def__doc__,
+"getmodulebydef_bad_def($self, /)\n"
+"--\n"
+"\n"
+"Test that result of PyType_GetModuleByDef with a bad def is NULL.");
+
+#define _TESTMULTIPHASE_STATEACCESSTYPE_GETMODULEBYDEF_BAD_DEF_METHODDEF    \
+    {"getmodulebydef_bad_def", _PyCFunction_CAST(_testmultiphase_StateAccessType_getmodulebydef_bad_def), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _testmultiphase_StateAccessType_getmodulebydef_bad_def__doc__},
+
+static PyObject *
+_testmultiphase_StateAccessType_getmodulebydef_bad_def_impl(StateAccessTypeObject *self,
+                                                            PyTypeObject *cls);
+
+static PyObject *
+_testmultiphase_StateAccessType_getmodulebydef_bad_def(StateAccessTypeObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "getmodulebydef_bad_def() takes no arguments");
+        return NULL;
+    }
+    return _testmultiphase_StateAccessType_getmodulebydef_bad_def_impl(self, cls);
+}
+
+PyDoc_STRVAR(_testmultiphase_StateAccessType_increment_count_clinic__doc__,
+"increment_count_clinic($self, /, n=1, *, twice=False)\n"
+"--\n"
+"\n"
+"Add \'n\' from the module-state counter.\n"
+"\n"
+"Pass \'twice\' to double that amount.\n"
+"\n"
+"This tests Argument Clinic support for defining_class.");
+
+#define _TESTMULTIPHASE_STATEACCESSTYPE_INCREMENT_COUNT_CLINIC_METHODDEF    \
+    {"increment_count_clinic", _PyCFunction_CAST(_testmultiphase_StateAccessType_increment_count_clinic), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _testmultiphase_StateAccessType_increment_count_clinic__doc__},
+
+static PyObject *
+_testmultiphase_StateAccessType_increment_count_clinic_impl(StateAccessTypeObject *self,
+                                                            PyTypeObject *cls,
+                                                            int n, int twice);
+
+static PyObject *
+_testmultiphase_StateAccessType_increment_count_clinic(StateAccessTypeObject *self, PyTypeObject *cls, 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 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(n), &_Py_ID(twice), },
+    };
+    #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[] = {"n", "twice", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "increment_count_clinic",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    int n = 1;
+    int twice = 0;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        n = _PyLong_AsInt(args[0]);
+        if (n == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    twice = PyObject_IsTrue(args[1]);
+    if (twice < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = _testmultiphase_StateAccessType_increment_count_clinic_impl(self, cls, n, twice);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_testmultiphase_StateAccessType_get_count__doc__,
+"get_count($self, /)\n"
+"--\n"
+"\n"
+"Return the value of the module-state counter.");
+
+#define _TESTMULTIPHASE_STATEACCESSTYPE_GET_COUNT_METHODDEF    \
+    {"get_count", _PyCFunction_CAST(_testmultiphase_StateAccessType_get_count), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _testmultiphase_StateAccessType_get_count__doc__},
+
+static PyObject *
+_testmultiphase_StateAccessType_get_count_impl(StateAccessTypeObject *self,
+                                               PyTypeObject *cls);
+
+static PyObject *
+_testmultiphase_StateAccessType_get_count(StateAccessTypeObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {
+        PyErr_SetString(PyExc_TypeError, "get_count() takes no arguments");
+        return NULL;
+    }
+    return _testmultiphase_StateAccessType_get_count_impl(self, cls);
+}
+/*[clinic end generated code: output=2193fe33d5e2b739 input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/_tkinter.c.h b/contrib/tools/python3/Modules/clinic/_tkinter.c.h
new file mode 100644
index 00000000000..57f208f3921
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/_tkinter.c.h
@@ -0,0 +1,895 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(_tkinter_tkapp_eval__doc__,
+"eval($self, script, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_EVAL_METHODDEF    \
+    {"eval", (PyCFunction)_tkinter_tkapp_eval, METH_O, _tkinter_tkapp_eval__doc__},
+
+static PyObject *
+_tkinter_tkapp_eval_impl(TkappObject *self, const char *script);
+
+static PyObject *
+_tkinter_tkapp_eval(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *script;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("eval", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t script_length;
+    script = PyUnicode_AsUTF8AndSize(arg, &script_length);
+    if (script == NULL) {
+        goto exit;
+    }
+    if (strlen(script) != (size_t)script_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_eval_impl(self, script);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_evalfile__doc__,
+"evalfile($self, fileName, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_EVALFILE_METHODDEF    \
+    {"evalfile", (PyCFunction)_tkinter_tkapp_evalfile, METH_O, _tkinter_tkapp_evalfile__doc__},
+
+static PyObject *
+_tkinter_tkapp_evalfile_impl(TkappObject *self, const char *fileName);
+
+static PyObject *
+_tkinter_tkapp_evalfile(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *fileName;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("evalfile", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t fileName_length;
+    fileName = PyUnicode_AsUTF8AndSize(arg, &fileName_length);
+    if (fileName == NULL) {
+        goto exit;
+    }
+    if (strlen(fileName) != (size_t)fileName_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_evalfile_impl(self, fileName);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_record__doc__,
+"record($self, script, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_RECORD_METHODDEF    \
+    {"record", (PyCFunction)_tkinter_tkapp_record, METH_O, _tkinter_tkapp_record__doc__},
+
+static PyObject *
+_tkinter_tkapp_record_impl(TkappObject *self, const char *script);
+
+static PyObject *
+_tkinter_tkapp_record(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *script;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("record", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t script_length;
+    script = PyUnicode_AsUTF8AndSize(arg, &script_length);
+    if (script == NULL) {
+        goto exit;
+    }
+    if (strlen(script) != (size_t)script_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_record_impl(self, script);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_adderrorinfo__doc__,
+"adderrorinfo($self, msg, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_ADDERRORINFO_METHODDEF    \
+    {"adderrorinfo", (PyCFunction)_tkinter_tkapp_adderrorinfo, METH_O, _tkinter_tkapp_adderrorinfo__doc__},
+
+static PyObject *
+_tkinter_tkapp_adderrorinfo_impl(TkappObject *self, const char *msg);
+
+static PyObject *
+_tkinter_tkapp_adderrorinfo(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *msg;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("adderrorinfo", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t msg_length;
+    msg = PyUnicode_AsUTF8AndSize(arg, &msg_length);
+    if (msg == NULL) {
+        goto exit;
+    }
+    if (strlen(msg) != (size_t)msg_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_adderrorinfo_impl(self, msg);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_getint__doc__,
+"getint($self, arg, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_GETINT_METHODDEF    \
+    {"getint", (PyCFunction)_tkinter_tkapp_getint, METH_O, _tkinter_tkapp_getint__doc__},
+
+PyDoc_STRVAR(_tkinter_tkapp_getdouble__doc__,
+"getdouble($self, arg, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_GETDOUBLE_METHODDEF    \
+    {"getdouble", (PyCFunction)_tkinter_tkapp_getdouble, METH_O, _tkinter_tkapp_getdouble__doc__},
+
+PyDoc_STRVAR(_tkinter_tkapp_getboolean__doc__,
+"getboolean($self, arg, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_GETBOOLEAN_METHODDEF    \
+    {"getboolean", (PyCFunction)_tkinter_tkapp_getboolean, METH_O, _tkinter_tkapp_getboolean__doc__},
+
+PyDoc_STRVAR(_tkinter_tkapp_exprstring__doc__,
+"exprstring($self, s, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_EXPRSTRING_METHODDEF    \
+    {"exprstring", (PyCFunction)_tkinter_tkapp_exprstring, METH_O, _tkinter_tkapp_exprstring__doc__},
+
+static PyObject *
+_tkinter_tkapp_exprstring_impl(TkappObject *self, const char *s);
+
+static PyObject *
+_tkinter_tkapp_exprstring(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *s;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("exprstring", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t s_length;
+    s = PyUnicode_AsUTF8AndSize(arg, &s_length);
+    if (s == NULL) {
+        goto exit;
+    }
+    if (strlen(s) != (size_t)s_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_exprstring_impl(self, s);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_exprlong__doc__,
+"exprlong($self, s, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_EXPRLONG_METHODDEF    \
+    {"exprlong", (PyCFunction)_tkinter_tkapp_exprlong, METH_O, _tkinter_tkapp_exprlong__doc__},
+
+static PyObject *
+_tkinter_tkapp_exprlong_impl(TkappObject *self, const char *s);
+
+static PyObject *
+_tkinter_tkapp_exprlong(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *s;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("exprlong", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t s_length;
+    s = PyUnicode_AsUTF8AndSize(arg, &s_length);
+    if (s == NULL) {
+        goto exit;
+    }
+    if (strlen(s) != (size_t)s_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_exprlong_impl(self, s);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_exprdouble__doc__,
+"exprdouble($self, s, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_EXPRDOUBLE_METHODDEF    \
+    {"exprdouble", (PyCFunction)_tkinter_tkapp_exprdouble, METH_O, _tkinter_tkapp_exprdouble__doc__},
+
+static PyObject *
+_tkinter_tkapp_exprdouble_impl(TkappObject *self, const char *s);
+
+static PyObject *
+_tkinter_tkapp_exprdouble(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *s;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("exprdouble", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t s_length;
+    s = PyUnicode_AsUTF8AndSize(arg, &s_length);
+    if (s == NULL) {
+        goto exit;
+    }
+    if (strlen(s) != (size_t)s_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_exprdouble_impl(self, s);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_exprboolean__doc__,
+"exprboolean($self, s, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_EXPRBOOLEAN_METHODDEF    \
+    {"exprboolean", (PyCFunction)_tkinter_tkapp_exprboolean, METH_O, _tkinter_tkapp_exprboolean__doc__},
+
+static PyObject *
+_tkinter_tkapp_exprboolean_impl(TkappObject *self, const char *s);
+
+static PyObject *
+_tkinter_tkapp_exprboolean(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *s;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("exprboolean", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t s_length;
+    s = PyUnicode_AsUTF8AndSize(arg, &s_length);
+    if (s == NULL) {
+        goto exit;
+    }
+    if (strlen(s) != (size_t)s_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_exprboolean_impl(self, s);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_splitlist__doc__,
+"splitlist($self, arg, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_SPLITLIST_METHODDEF    \
+    {"splitlist", (PyCFunction)_tkinter_tkapp_splitlist, METH_O, _tkinter_tkapp_splitlist__doc__},
+
+PyDoc_STRVAR(_tkinter_tkapp_createcommand__doc__,
+"createcommand($self, name, func, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_CREATECOMMAND_METHODDEF    \
+    {"createcommand", _PyCFunction_CAST(_tkinter_tkapp_createcommand), METH_FASTCALL, _tkinter_tkapp_createcommand__doc__},
+
+static PyObject *
+_tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
+                                  PyObject *func);
+
+static PyObject *
+_tkinter_tkapp_createcommand(TkappObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    const char *name;
+    PyObject *func;
+
+    if (!_PyArg_CheckPositional("createcommand", nargs, 2, 2)) {
+        goto exit;
+    }
+    if (!PyUnicode_Check(args[0])) {
+        _PyArg_BadArgument("createcommand", "argument 1", "str", args[0]);
+        goto exit;
+    }
+    Py_ssize_t name_length;
+    name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
+    if (name == NULL) {
+        goto exit;
+    }
+    if (strlen(name) != (size_t)name_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    func = args[1];
+    return_value = _tkinter_tkapp_createcommand_impl(self, name, func);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_deletecommand__doc__,
+"deletecommand($self, name, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_DELETECOMMAND_METHODDEF    \
+    {"deletecommand", (PyCFunction)_tkinter_tkapp_deletecommand, METH_O, _tkinter_tkapp_deletecommand__doc__},
+
+static PyObject *
+_tkinter_tkapp_deletecommand_impl(TkappObject *self, const char *name);
+
+static PyObject *
+_tkinter_tkapp_deletecommand(TkappObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *name;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("deletecommand", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t name_length;
+    name = PyUnicode_AsUTF8AndSize(arg, &name_length);
+    if (name == NULL) {
+        goto exit;
+    }
+    if (strlen(name) != (size_t)name_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _tkinter_tkapp_deletecommand_impl(self, name);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_CREATEFILEHANDLER)
+
+PyDoc_STRVAR(_tkinter_tkapp_createfilehandler__doc__,
+"createfilehandler($self, file, mask, func, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF    \
+    {"createfilehandler", _PyCFunction_CAST(_tkinter_tkapp_createfilehandler), METH_FASTCALL, _tkinter_tkapp_createfilehandler__doc__},
+
+static PyObject *
+_tkinter_tkapp_createfilehandler_impl(TkappObject *self, PyObject *file,
+                                      int mask, PyObject *func);
+
+static PyObject *
+_tkinter_tkapp_createfilehandler(TkappObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *file;
+    int mask;
+    PyObject *func;
+
+    if (!_PyArg_CheckPositional("createfilehandler", nargs, 3, 3)) {
+        goto exit;
+    }
+    file = args[0];
+    mask = _PyLong_AsInt(args[1]);
+    if (mask == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    func = args[2];
+    return_value = _tkinter_tkapp_createfilehandler_impl(self, file, mask, func);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_CREATEFILEHANDLER) */
+
+#if defined(HAVE_CREATEFILEHANDLER)
+
+PyDoc_STRVAR(_tkinter_tkapp_deletefilehandler__doc__,
+"deletefilehandler($self, file, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF    \
+    {"deletefilehandler", (PyCFunction)_tkinter_tkapp_deletefilehandler, METH_O, _tkinter_tkapp_deletefilehandler__doc__},
+
+#endif /* defined(HAVE_CREATEFILEHANDLER) */
+
+PyDoc_STRVAR(_tkinter_tktimertoken_deletetimerhandler__doc__,
+"deletetimerhandler($self, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKTIMERTOKEN_DELETETIMERHANDLER_METHODDEF    \
+    {"deletetimerhandler", (PyCFunction)_tkinter_tktimertoken_deletetimerhandler, METH_NOARGS, _tkinter_tktimertoken_deletetimerhandler__doc__},
+
+static PyObject *
+_tkinter_tktimertoken_deletetimerhandler_impl(TkttObject *self);
+
+static PyObject *
+_tkinter_tktimertoken_deletetimerhandler(TkttObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _tkinter_tktimertoken_deletetimerhandler_impl(self);
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_createtimerhandler__doc__,
+"createtimerhandler($self, milliseconds, func, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_CREATETIMERHANDLER_METHODDEF    \
+    {"createtimerhandler", _PyCFunction_CAST(_tkinter_tkapp_createtimerhandler), METH_FASTCALL, _tkinter_tkapp_createtimerhandler__doc__},
+
+static PyObject *
+_tkinter_tkapp_createtimerhandler_impl(TkappObject *self, int milliseconds,
+                                       PyObject *func);
+
+static PyObject *
+_tkinter_tkapp_createtimerhandler(TkappObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int milliseconds;
+    PyObject *func;
+
+    if (!_PyArg_CheckPositional("createtimerhandler", nargs, 2, 2)) {
+        goto exit;
+    }
+    milliseconds = _PyLong_AsInt(args[0]);
+    if (milliseconds == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    func = args[1];
+    return_value = _tkinter_tkapp_createtimerhandler_impl(self, milliseconds, func);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_mainloop__doc__,
+"mainloop($self, threshold=0, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_MAINLOOP_METHODDEF    \
+    {"mainloop", _PyCFunction_CAST(_tkinter_tkapp_mainloop), METH_FASTCALL, _tkinter_tkapp_mainloop__doc__},
+
+static PyObject *
+_tkinter_tkapp_mainloop_impl(TkappObject *self, int threshold);
+
+static PyObject *
+_tkinter_tkapp_mainloop(TkappObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int threshold = 0;
+
+    if (!_PyArg_CheckPositional("mainloop", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    threshold = _PyLong_AsInt(args[0]);
+    if (threshold == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _tkinter_tkapp_mainloop_impl(self, threshold);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_dooneevent__doc__,
+"dooneevent($self, flags=0, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_DOONEEVENT_METHODDEF    \
+    {"dooneevent", _PyCFunction_CAST(_tkinter_tkapp_dooneevent), METH_FASTCALL, _tkinter_tkapp_dooneevent__doc__},
+
+static PyObject *
+_tkinter_tkapp_dooneevent_impl(TkappObject *self, int flags);
+
+static PyObject *
+_tkinter_tkapp_dooneevent(TkappObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int flags = 0;
+
+    if (!_PyArg_CheckPositional("dooneevent", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    flags = _PyLong_AsInt(args[0]);
+    if (flags == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional:
+    return_value = _tkinter_tkapp_dooneevent_impl(self, flags);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_quit__doc__,
+"quit($self, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_QUIT_METHODDEF    \
+    {"quit", (PyCFunction)_tkinter_tkapp_quit, METH_NOARGS, _tkinter_tkapp_quit__doc__},
+
+static PyObject *
+_tkinter_tkapp_quit_impl(TkappObject *self);
+
+static PyObject *
+_tkinter_tkapp_quit(TkappObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _tkinter_tkapp_quit_impl(self);
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_interpaddr__doc__,
+"interpaddr($self, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_INTERPADDR_METHODDEF    \
+    {"interpaddr", (PyCFunction)_tkinter_tkapp_interpaddr, METH_NOARGS, _tkinter_tkapp_interpaddr__doc__},
+
+static PyObject *
+_tkinter_tkapp_interpaddr_impl(TkappObject *self);
+
+static PyObject *
+_tkinter_tkapp_interpaddr(TkappObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _tkinter_tkapp_interpaddr_impl(self);
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_loadtk__doc__,
+"loadtk($self, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_LOADTK_METHODDEF    \
+    {"loadtk", (PyCFunction)_tkinter_tkapp_loadtk, METH_NOARGS, _tkinter_tkapp_loadtk__doc__},
+
+static PyObject *
+_tkinter_tkapp_loadtk_impl(TkappObject *self);
+
+static PyObject *
+_tkinter_tkapp_loadtk(TkappObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _tkinter_tkapp_loadtk_impl(self);
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_settrace__doc__,
+"settrace($self, func, /)\n"
+"--\n"
+"\n"
+"Set the tracing function.");
+
+#define _TKINTER_TKAPP_SETTRACE_METHODDEF    \
+    {"settrace", (PyCFunction)_tkinter_tkapp_settrace, METH_O, _tkinter_tkapp_settrace__doc__},
+
+PyDoc_STRVAR(_tkinter_tkapp_gettrace__doc__,
+"gettrace($self, /)\n"
+"--\n"
+"\n"
+"Get the tracing function.");
+
+#define _TKINTER_TKAPP_GETTRACE_METHODDEF    \
+    {"gettrace", (PyCFunction)_tkinter_tkapp_gettrace, METH_NOARGS, _tkinter_tkapp_gettrace__doc__},
+
+static PyObject *
+_tkinter_tkapp_gettrace_impl(TkappObject *self);
+
+static PyObject *
+_tkinter_tkapp_gettrace(TkappObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _tkinter_tkapp_gettrace_impl(self);
+}
+
+PyDoc_STRVAR(_tkinter_tkapp_willdispatch__doc__,
+"willdispatch($self, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER_TKAPP_WILLDISPATCH_METHODDEF    \
+    {"willdispatch", (PyCFunction)_tkinter_tkapp_willdispatch, METH_NOARGS, _tkinter_tkapp_willdispatch__doc__},
+
+static PyObject *
+_tkinter_tkapp_willdispatch_impl(TkappObject *self);
+
+static PyObject *
+_tkinter_tkapp_willdispatch(TkappObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _tkinter_tkapp_willdispatch_impl(self);
+}
+
+PyDoc_STRVAR(_tkinter__flatten__doc__,
+"_flatten($module, item, /)\n"
+"--\n"
+"\n");
+
+#define _TKINTER__FLATTEN_METHODDEF    \
+    {"_flatten", (PyCFunction)_tkinter__flatten, METH_O, _tkinter__flatten__doc__},
+
+PyDoc_STRVAR(_tkinter_create__doc__,
+"create($module, screenName=None, baseName=\'\', className=\'Tk\',\n"
+"       interactive=False, wantobjects=False, wantTk=True, sync=False,\n"
+"       use=None, /)\n"
+"--\n"
+"\n"
+"\n"
+"\n"
+"  wantTk\n"
+"    if false, then Tk_Init() doesn\'t get called\n"
+"  sync\n"
+"    if true, then pass -sync to wish\n"
+"  use\n"
+"    if not None, then pass -use to wish");
+
+#define _TKINTER_CREATE_METHODDEF    \
+    {"create", _PyCFunction_CAST(_tkinter_create), METH_FASTCALL, _tkinter_create__doc__},
+
+static PyObject *
+_tkinter_create_impl(PyObject *module, const char *screenName,
+                     const char *baseName, const char *className,
+                     int interactive, int wantobjects, int wantTk, int sync,
+                     const char *use);
+
+static PyObject *
+_tkinter_create(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    const char *screenName = NULL;
+    const char *baseName = "";
+    const char *className = "Tk";
+    int interactive = 0;
+    int wantobjects = 0;
+    int wantTk = 1;
+    int sync = 0;
+    const char *use = NULL;
+
+    if (!_PyArg_CheckPositional("create", nargs, 0, 8)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    if (args[0] == Py_None) {
+        screenName = NULL;
+    }
+    else if (PyUnicode_Check(args[0])) {
+        Py_ssize_t screenName_length;
+        screenName = PyUnicode_AsUTF8AndSize(args[0], &screenName_length);
+        if (screenName == NULL) {
+            goto exit;
+        }
+        if (strlen(screenName) != (size_t)screenName_length) {
+            PyErr_SetString(PyExc_ValueError, "embedded null character");
+            goto exit;
+        }
+    }
+    else {
+        _PyArg_BadArgument("create", "argument 1", "str or None", args[0]);
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    if (!PyUnicode_Check(args[1])) {
+        _PyArg_BadArgument("create", "argument 2", "str", args[1]);
+        goto exit;
+    }
+    Py_ssize_t baseName_length;
+    baseName = PyUnicode_AsUTF8AndSize(args[1], &baseName_length);
+    if (baseName == NULL) {
+        goto exit;
+    }
+    if (strlen(baseName) != (size_t)baseName_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    if (!PyUnicode_Check(args[2])) {
+        _PyArg_BadArgument("create", "argument 3", "str", args[2]);
+        goto exit;
+    }
+    Py_ssize_t className_length;
+    className = PyUnicode_AsUTF8AndSize(args[2], &className_length);
+    if (className == NULL) {
+        goto exit;
+    }
+    if (strlen(className) != (size_t)className_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    if (nargs < 4) {
+        goto skip_optional;
+    }
+    interactive = PyObject_IsTrue(args[3]);
+    if (interactive < 0) {
+        goto exit;
+    }
+    if (nargs < 5) {
+        goto skip_optional;
+    }
+    wantobjects = PyObject_IsTrue(args[4]);
+    if (wantobjects < 0) {
+        goto exit;
+    }
+    if (nargs < 6) {
+        goto skip_optional;
+    }
+    wantTk = PyObject_IsTrue(args[5]);
+    if (wantTk < 0) {
+        goto exit;
+    }
+    if (nargs < 7) {
+        goto skip_optional;
+    }
+    sync = PyObject_IsTrue(args[6]);
+    if (sync < 0) {
+        goto exit;
+    }
+    if (nargs < 8) {
+        goto skip_optional;
+    }
+    if (args[7] == Py_None) {
+        use = NULL;
+    }
+    else if (PyUnicode_Check(args[7])) {
+        Py_ssize_t use_length;
+        use = PyUnicode_AsUTF8AndSize(args[7], &use_length);
+        if (use == NULL) {
+            goto exit;
+        }
+        if (strlen(use) != (size_t)use_length) {
+            PyErr_SetString(PyExc_ValueError, "embedded null character");
+            goto exit;
+        }
+    }
+    else {
+        _PyArg_BadArgument("create", "argument 8", "str or None", args[7]);
+        goto exit;
+    }
+skip_optional:
+    return_value = _tkinter_create_impl(module, screenName, baseName, className, interactive, wantobjects, wantTk, sync, use);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_setbusywaitinterval__doc__,
+"setbusywaitinterval($module, new_val, /)\n"
+"--\n"
+"\n"
+"Set the busy-wait interval in milliseconds between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.\n"
+"\n"
+"It should be set to a divisor of the maximum time between frames in an animation.");
+
+#define _TKINTER_SETBUSYWAITINTERVAL_METHODDEF    \
+    {"setbusywaitinterval", (PyCFunction)_tkinter_setbusywaitinterval, METH_O, _tkinter_setbusywaitinterval__doc__},
+
+static PyObject *
+_tkinter_setbusywaitinterval_impl(PyObject *module, int new_val);
+
+static PyObject *
+_tkinter_setbusywaitinterval(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 = _tkinter_setbusywaitinterval_impl(module, new_val);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_tkinter_getbusywaitinterval__doc__,
+"getbusywaitinterval($module, /)\n"
+"--\n"
+"\n"
+"Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.");
+
+#define _TKINTER_GETBUSYWAITINTERVAL_METHODDEF    \
+    {"getbusywaitinterval", (PyCFunction)_tkinter_getbusywaitinterval, METH_NOARGS, _tkinter_getbusywaitinterval__doc__},
+
+static int
+_tkinter_getbusywaitinterval_impl(PyObject *module);
+
+static PyObject *
+_tkinter_getbusywaitinterval(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+    int _return_value;
+
+    _return_value = _tkinter_getbusywaitinterval_impl(module);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromLong((long)_return_value);
+
+exit:
+    return return_value;
+}
+
+#ifndef _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF
+    #define _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF
+#endif /* !defined(_TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF) */
+
+#ifndef _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
+    #define _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
+#endif /* !defined(_TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF) */
+/*[clinic end generated code: output=61ba8eef2e489a1b input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/clinic/readline.c.h b/contrib/tools/python3/Modules/clinic/readline.c.h
new file mode 100644
index 00000000000..e36d651f67f
--- /dev/null
+++ b/contrib/tools/python3/Modules/clinic/readline.c.h
@@ -0,0 +1,694 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(readline_parse_and_bind__doc__,
+"parse_and_bind($module, string, /)\n"
+"--\n"
+"\n"
+"Execute the init line provided in the string argument.");
+
+#define READLINE_PARSE_AND_BIND_METHODDEF    \
+    {"parse_and_bind", (PyCFunction)readline_parse_and_bind, METH_O, readline_parse_and_bind__doc__},
+
+PyDoc_STRVAR(readline_read_init_file__doc__,
+"read_init_file($module, filename=None, /)\n"
+"--\n"
+"\n"
+"Execute a readline initialization file.\n"
+"\n"
+"The default filename is the last filename used.");
+
+#define READLINE_READ_INIT_FILE_METHODDEF    \
+    {"read_init_file", _PyCFunction_CAST(readline_read_init_file), METH_FASTCALL, readline_read_init_file__doc__},
+
+static PyObject *
+readline_read_init_file_impl(PyObject *module, PyObject *filename_obj);
+
+static PyObject *
+readline_read_init_file(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *filename_obj = Py_None;
+
+    if (!_PyArg_CheckPositional("read_init_file", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    filename_obj = args[0];
+skip_optional:
+    return_value = readline_read_init_file_impl(module, filename_obj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_read_history_file__doc__,
+"read_history_file($module, filename=None, /)\n"
+"--\n"
+"\n"
+"Load a readline history file.\n"
+"\n"
+"The default filename is ~/.history.");
+
+#define READLINE_READ_HISTORY_FILE_METHODDEF    \
+    {"read_history_file", _PyCFunction_CAST(readline_read_history_file), METH_FASTCALL, readline_read_history_file__doc__},
+
+static PyObject *
+readline_read_history_file_impl(PyObject *module, PyObject *filename_obj);
+
+static PyObject *
+readline_read_history_file(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *filename_obj = Py_None;
+
+    if (!_PyArg_CheckPositional("read_history_file", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    filename_obj = args[0];
+skip_optional:
+    return_value = readline_read_history_file_impl(module, filename_obj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_write_history_file__doc__,
+"write_history_file($module, filename=None, /)\n"
+"--\n"
+"\n"
+"Save a readline history file.\n"
+"\n"
+"The default filename is ~/.history.");
+
+#define READLINE_WRITE_HISTORY_FILE_METHODDEF    \
+    {"write_history_file", _PyCFunction_CAST(readline_write_history_file), METH_FASTCALL, readline_write_history_file__doc__},
+
+static PyObject *
+readline_write_history_file_impl(PyObject *module, PyObject *filename_obj);
+
+static PyObject *
+readline_write_history_file(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *filename_obj = Py_None;
+
+    if (!_PyArg_CheckPositional("write_history_file", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    filename_obj = args[0];
+skip_optional:
+    return_value = readline_write_history_file_impl(module, filename_obj);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_RL_APPEND_HISTORY)
+
+PyDoc_STRVAR(readline_append_history_file__doc__,
+"append_history_file($module, nelements, filename=None, /)\n"
+"--\n"
+"\n"
+"Append the last nelements items of the history list to file.\n"
+"\n"
+"The default filename is ~/.history.");
+
+#define READLINE_APPEND_HISTORY_FILE_METHODDEF    \
+    {"append_history_file", _PyCFunction_CAST(readline_append_history_file), METH_FASTCALL, readline_append_history_file__doc__},
+
+static PyObject *
+readline_append_history_file_impl(PyObject *module, int nelements,
+                                  PyObject *filename_obj);
+
+static PyObject *
+readline_append_history_file(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int nelements;
+    PyObject *filename_obj = Py_None;
+
+    if (!_PyArg_CheckPositional("append_history_file", nargs, 1, 2)) {
+        goto exit;
+    }
+    nelements = _PyLong_AsInt(args[0]);
+    if (nelements == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    filename_obj = args[1];
+skip_optional:
+    return_value = readline_append_history_file_impl(module, nelements, filename_obj);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_RL_APPEND_HISTORY) */
+
+PyDoc_STRVAR(readline_set_history_length__doc__,
+"set_history_length($module, length, /)\n"
+"--\n"
+"\n"
+"Set the maximal number of lines which will be written to the history file.\n"
+"\n"
+"A negative length is used to inhibit history truncation.");
+
+#define READLINE_SET_HISTORY_LENGTH_METHODDEF    \
+    {"set_history_length", (PyCFunction)readline_set_history_length, METH_O, readline_set_history_length__doc__},
+
+static PyObject *
+readline_set_history_length_impl(PyObject *module, int length);
+
+static PyObject *
+readline_set_history_length(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int length;
+
+    length = _PyLong_AsInt(arg);
+    if (length == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = readline_set_history_length_impl(module, length);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_get_history_length__doc__,
+"get_history_length($module, /)\n"
+"--\n"
+"\n"
+"Return the maximum number of lines that will be written to the history file.");
+
+#define READLINE_GET_HISTORY_LENGTH_METHODDEF    \
+    {"get_history_length", (PyCFunction)readline_get_history_length, METH_NOARGS, readline_get_history_length__doc__},
+
+static PyObject *
+readline_get_history_length_impl(PyObject *module);
+
+static PyObject *
+readline_get_history_length(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_history_length_impl(module);
+}
+
+PyDoc_STRVAR(readline_set_completion_display_matches_hook__doc__,
+"set_completion_display_matches_hook($module, function=None, /)\n"
+"--\n"
+"\n"
+"Set or remove the completion display function.\n"
+"\n"
+"The function is called as\n"
+"  function(substitution, [matches], longest_match_length)\n"
+"once each time matches need to be displayed.");
+
+#define READLINE_SET_COMPLETION_DISPLAY_MATCHES_HOOK_METHODDEF    \
+    {"set_completion_display_matches_hook", _PyCFunction_CAST(readline_set_completion_display_matches_hook), METH_FASTCALL, readline_set_completion_display_matches_hook__doc__},
+
+static PyObject *
+readline_set_completion_display_matches_hook_impl(PyObject *module,
+                                                  PyObject *function);
+
+static PyObject *
+readline_set_completion_display_matches_hook(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *function = Py_None;
+
+    if (!_PyArg_CheckPositional("set_completion_display_matches_hook", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    function = args[0];
+skip_optional:
+    return_value = readline_set_completion_display_matches_hook_impl(module, function);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_set_startup_hook__doc__,
+"set_startup_hook($module, function=None, /)\n"
+"--\n"
+"\n"
+"Set or remove the function invoked by the rl_startup_hook callback.\n"
+"\n"
+"The function is called with no arguments just\n"
+"before readline prints the first prompt.");
+
+#define READLINE_SET_STARTUP_HOOK_METHODDEF    \
+    {"set_startup_hook", _PyCFunction_CAST(readline_set_startup_hook), METH_FASTCALL, readline_set_startup_hook__doc__},
+
+static PyObject *
+readline_set_startup_hook_impl(PyObject *module, PyObject *function);
+
+static PyObject *
+readline_set_startup_hook(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *function = Py_None;
+
+    if (!_PyArg_CheckPositional("set_startup_hook", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    function = args[0];
+skip_optional:
+    return_value = readline_set_startup_hook_impl(module, function);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_RL_PRE_INPUT_HOOK)
+
+PyDoc_STRVAR(readline_set_pre_input_hook__doc__,
+"set_pre_input_hook($module, function=None, /)\n"
+"--\n"
+"\n"
+"Set or remove the function invoked by the rl_pre_input_hook callback.\n"
+"\n"
+"The function is called with no arguments after the first prompt\n"
+"has been printed and just before readline starts reading input\n"
+"characters.");
+
+#define READLINE_SET_PRE_INPUT_HOOK_METHODDEF    \
+    {"set_pre_input_hook", _PyCFunction_CAST(readline_set_pre_input_hook), METH_FASTCALL, readline_set_pre_input_hook__doc__},
+
+static PyObject *
+readline_set_pre_input_hook_impl(PyObject *module, PyObject *function);
+
+static PyObject *
+readline_set_pre_input_hook(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *function = Py_None;
+
+    if (!_PyArg_CheckPositional("set_pre_input_hook", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    function = args[0];
+skip_optional:
+    return_value = readline_set_pre_input_hook_impl(module, function);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_RL_PRE_INPUT_HOOK) */
+
+PyDoc_STRVAR(readline_get_completion_type__doc__,
+"get_completion_type($module, /)\n"
+"--\n"
+"\n"
+"Get the type of completion being attempted.");
+
+#define READLINE_GET_COMPLETION_TYPE_METHODDEF    \
+    {"get_completion_type", (PyCFunction)readline_get_completion_type, METH_NOARGS, readline_get_completion_type__doc__},
+
+static PyObject *
+readline_get_completion_type_impl(PyObject *module);
+
+static PyObject *
+readline_get_completion_type(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_completion_type_impl(module);
+}
+
+PyDoc_STRVAR(readline_get_begidx__doc__,
+"get_begidx($module, /)\n"
+"--\n"
+"\n"
+"Get the beginning index of the completion scope.");
+
+#define READLINE_GET_BEGIDX_METHODDEF    \
+    {"get_begidx", (PyCFunction)readline_get_begidx, METH_NOARGS, readline_get_begidx__doc__},
+
+static PyObject *
+readline_get_begidx_impl(PyObject *module);
+
+static PyObject *
+readline_get_begidx(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_begidx_impl(module);
+}
+
+PyDoc_STRVAR(readline_get_endidx__doc__,
+"get_endidx($module, /)\n"
+"--\n"
+"\n"
+"Get the ending index of the completion scope.");
+
+#define READLINE_GET_ENDIDX_METHODDEF    \
+    {"get_endidx", (PyCFunction)readline_get_endidx, METH_NOARGS, readline_get_endidx__doc__},
+
+static PyObject *
+readline_get_endidx_impl(PyObject *module);
+
+static PyObject *
+readline_get_endidx(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_endidx_impl(module);
+}
+
+PyDoc_STRVAR(readline_set_completer_delims__doc__,
+"set_completer_delims($module, string, /)\n"
+"--\n"
+"\n"
+"Set the word delimiters for completion.");
+
+#define READLINE_SET_COMPLETER_DELIMS_METHODDEF    \
+    {"set_completer_delims", (PyCFunction)readline_set_completer_delims, METH_O, readline_set_completer_delims__doc__},
+
+PyDoc_STRVAR(readline_remove_history_item__doc__,
+"remove_history_item($module, pos, /)\n"
+"--\n"
+"\n"
+"Remove history item given by its zero-based position.");
+
+#define READLINE_REMOVE_HISTORY_ITEM_METHODDEF    \
+    {"remove_history_item", (PyCFunction)readline_remove_history_item, METH_O, readline_remove_history_item__doc__},
+
+static PyObject *
+readline_remove_history_item_impl(PyObject *module, int entry_number);
+
+static PyObject *
+readline_remove_history_item(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int entry_number;
+
+    entry_number = _PyLong_AsInt(arg);
+    if (entry_number == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = readline_remove_history_item_impl(module, entry_number);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_replace_history_item__doc__,
+"replace_history_item($module, pos, line, /)\n"
+"--\n"
+"\n"
+"Replaces history item given by its position with contents of line.\n"
+"\n"
+"pos is zero-based.");
+
+#define READLINE_REPLACE_HISTORY_ITEM_METHODDEF    \
+    {"replace_history_item", _PyCFunction_CAST(readline_replace_history_item), METH_FASTCALL, readline_replace_history_item__doc__},
+
+static PyObject *
+readline_replace_history_item_impl(PyObject *module, int entry_number,
+                                   PyObject *line);
+
+static PyObject *
+readline_replace_history_item(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int entry_number;
+    PyObject *line;
+
+    if (!_PyArg_CheckPositional("replace_history_item", nargs, 2, 2)) {
+        goto exit;
+    }
+    entry_number = _PyLong_AsInt(args[0]);
+    if (entry_number == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (!PyUnicode_Check(args[1])) {
+        _PyArg_BadArgument("replace_history_item", "argument 2", "str", args[1]);
+        goto exit;
+    }
+    if (PyUnicode_READY(args[1]) == -1) {
+        goto exit;
+    }
+    line = args[1];
+    return_value = readline_replace_history_item_impl(module, entry_number, line);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_add_history__doc__,
+"add_history($module, string, /)\n"
+"--\n"
+"\n"
+"Add an item to the history buffer.");
+
+#define READLINE_ADD_HISTORY_METHODDEF    \
+    {"add_history", (PyCFunction)readline_add_history, METH_O, readline_add_history__doc__},
+
+PyDoc_STRVAR(readline_set_auto_history__doc__,
+"set_auto_history($module, enabled, /)\n"
+"--\n"
+"\n"
+"Enables or disables automatic history.");
+
+#define READLINE_SET_AUTO_HISTORY_METHODDEF    \
+    {"set_auto_history", (PyCFunction)readline_set_auto_history, METH_O, readline_set_auto_history__doc__},
+
+static PyObject *
+readline_set_auto_history_impl(PyObject *module,
+                               int _should_auto_add_history);
+
+static PyObject *
+readline_set_auto_history(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int _should_auto_add_history;
+
+    _should_auto_add_history = PyObject_IsTrue(arg);
+    if (_should_auto_add_history < 0) {
+        goto exit;
+    }
+    return_value = readline_set_auto_history_impl(module, _should_auto_add_history);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_get_completer_delims__doc__,
+"get_completer_delims($module, /)\n"
+"--\n"
+"\n"
+"Get the word delimiters for completion.");
+
+#define READLINE_GET_COMPLETER_DELIMS_METHODDEF    \
+    {"get_completer_delims", (PyCFunction)readline_get_completer_delims, METH_NOARGS, readline_get_completer_delims__doc__},
+
+static PyObject *
+readline_get_completer_delims_impl(PyObject *module);
+
+static PyObject *
+readline_get_completer_delims(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_completer_delims_impl(module);
+}
+
+PyDoc_STRVAR(readline_set_completer__doc__,
+"set_completer($module, function=None, /)\n"
+"--\n"
+"\n"
+"Set or remove the completer function.\n"
+"\n"
+"The function is called as function(text, state),\n"
+"for state in 0, 1, 2, ..., until it returns a non-string.\n"
+"It should return the next possible completion starting with \'text\'.");
+
+#define READLINE_SET_COMPLETER_METHODDEF    \
+    {"set_completer", _PyCFunction_CAST(readline_set_completer), METH_FASTCALL, readline_set_completer__doc__},
+
+static PyObject *
+readline_set_completer_impl(PyObject *module, PyObject *function);
+
+static PyObject *
+readline_set_completer(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *function = Py_None;
+
+    if (!_PyArg_CheckPositional("set_completer", nargs, 0, 1)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    function = args[0];
+skip_optional:
+    return_value = readline_set_completer_impl(module, function);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_get_completer__doc__,
+"get_completer($module, /)\n"
+"--\n"
+"\n"
+"Get the current completer function.");
+
+#define READLINE_GET_COMPLETER_METHODDEF    \
+    {"get_completer", (PyCFunction)readline_get_completer, METH_NOARGS, readline_get_completer__doc__},
+
+static PyObject *
+readline_get_completer_impl(PyObject *module);
+
+static PyObject *
+readline_get_completer(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_completer_impl(module);
+}
+
+PyDoc_STRVAR(readline_get_history_item__doc__,
+"get_history_item($module, index, /)\n"
+"--\n"
+"\n"
+"Return the current contents of history item at one-based index.");
+
+#define READLINE_GET_HISTORY_ITEM_METHODDEF    \
+    {"get_history_item", (PyCFunction)readline_get_history_item, METH_O, readline_get_history_item__doc__},
+
+static PyObject *
+readline_get_history_item_impl(PyObject *module, int idx);
+
+static PyObject *
+readline_get_history_item(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int idx;
+
+    idx = _PyLong_AsInt(arg);
+    if (idx == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = readline_get_history_item_impl(module, idx);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(readline_get_current_history_length__doc__,
+"get_current_history_length($module, /)\n"
+"--\n"
+"\n"
+"Return the current (not the maximum) length of history.");
+
+#define READLINE_GET_CURRENT_HISTORY_LENGTH_METHODDEF    \
+    {"get_current_history_length", (PyCFunction)readline_get_current_history_length, METH_NOARGS, readline_get_current_history_length__doc__},
+
+static PyObject *
+readline_get_current_history_length_impl(PyObject *module);
+
+static PyObject *
+readline_get_current_history_length(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_current_history_length_impl(module);
+}
+
+PyDoc_STRVAR(readline_get_line_buffer__doc__,
+"get_line_buffer($module, /)\n"
+"--\n"
+"\n"
+"Return the current contents of the line buffer.");
+
+#define READLINE_GET_LINE_BUFFER_METHODDEF    \
+    {"get_line_buffer", (PyCFunction)readline_get_line_buffer, METH_NOARGS, readline_get_line_buffer__doc__},
+
+static PyObject *
+readline_get_line_buffer_impl(PyObject *module);
+
+static PyObject *
+readline_get_line_buffer(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_get_line_buffer_impl(module);
+}
+
+#if defined(HAVE_RL_COMPLETION_APPEND_CHARACTER)
+
+PyDoc_STRVAR(readline_clear_history__doc__,
+"clear_history($module, /)\n"
+"--\n"
+"\n"
+"Clear the current readline history.");
+
+#define READLINE_CLEAR_HISTORY_METHODDEF    \
+    {"clear_history", (PyCFunction)readline_clear_history, METH_NOARGS, readline_clear_history__doc__},
+
+static PyObject *
+readline_clear_history_impl(PyObject *module);
+
+static PyObject *
+readline_clear_history(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_clear_history_impl(module);
+}
+
+#endif /* defined(HAVE_RL_COMPLETION_APPEND_CHARACTER) */
+
+PyDoc_STRVAR(readline_insert_text__doc__,
+"insert_text($module, string, /)\n"
+"--\n"
+"\n"
+"Insert text into the line buffer at the cursor position.");
+
+#define READLINE_INSERT_TEXT_METHODDEF    \
+    {"insert_text", (PyCFunction)readline_insert_text, METH_O, readline_insert_text__doc__},
+
+PyDoc_STRVAR(readline_redisplay__doc__,
+"redisplay($module, /)\n"
+"--\n"
+"\n"
+"Change what\'s displayed on the screen to reflect contents of the line buffer.");
+
+#define READLINE_REDISPLAY_METHODDEF    \
+    {"redisplay", (PyCFunction)readline_redisplay, METH_NOARGS, readline_redisplay__doc__},
+
+static PyObject *
+readline_redisplay_impl(PyObject *module);
+
+static PyObject *
+readline_redisplay(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return readline_redisplay_impl(module);
+}
+
+#ifndef READLINE_APPEND_HISTORY_FILE_METHODDEF
+    #define READLINE_APPEND_HISTORY_FILE_METHODDEF
+#endif /* !defined(READLINE_APPEND_HISTORY_FILE_METHODDEF) */
+
+#ifndef READLINE_SET_PRE_INPUT_HOOK_METHODDEF
+    #define READLINE_SET_PRE_INPUT_HOOK_METHODDEF
+#endif /* !defined(READLINE_SET_PRE_INPUT_HOOK_METHODDEF) */
+
+#ifndef READLINE_CLEAR_HISTORY_METHODDEF
+    #define READLINE_CLEAR_HISTORY_METHODDEF
+#endif /* !defined(READLINE_CLEAR_HISTORY_METHODDEF) */
+/*[clinic end generated code: output=9097fcb749c19e27 input=a9049054013a1b77]*/
diff --git a/contrib/tools/python3/Modules/tkinter.h b/contrib/tools/python3/Modules/tkinter.h
new file mode 100644
index 00000000000..40281c21760
--- /dev/null
+++ b/contrib/tools/python3/Modules/tkinter.h
@@ -0,0 +1,19 @@
+#ifndef TKINTER_H
+#define TKINTER_H
+
+/* This header is used to share some macros between _tkinter.c and
+ * tkappinit.c.
+ * Be sure to include tk.h before including this header so
+ * TK_HEX_VERSION is properly defined. */
+
+/* TK_RELEASE_LEVEL is always one of the following:
+ *  TCL_ALPHA_RELEASE   0
+ *  TCL_BETA_RELEASE    1
+ *  TCL_FINAL_RELEASE   2
+ */
+#define TK_HEX_VERSION ((TK_MAJOR_VERSION << 24) | \
+                        (TK_MINOR_VERSION << 16) | \
+                        (TK_RELEASE_LEVEL << 8) | \
+                        (TK_RELEASE_SERIAL << 0))
+
+#endif /* !TKINTER_H */