Nuitka-winsvc 2.2.3__cp311-cp311-win_amd64.whl → 2.3.2__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersCallingGenerated.c

@@ -90,6 +90,44 @@ PyObject *CALL_FUNCTION_NO_ARGS(PyThreadState *tstate, PyObject *called) {
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, NULL, 0, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = const_tuple_empty;
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -163,7 +201,8 @@ PyObject *CALL_FUNCTION_NO_ARGS(PyThreadState *tstate, PyObject *called) {
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunctionNoArgs(called);
@@ -471,6 +510,46 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 1, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -512,7 +591,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 1);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -522,19 +601,19 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 1);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 1, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 1);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 1);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 1);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -549,7 +628,8 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 1);
@@ -590,7 +670,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 1);
+                pos_args = MAKE_TUPLE(tstate, args, 1);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -663,7 +743,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 1);
+                            pos_args = MAKE_TUPLE(tstate, args, 1);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -762,7 +842,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 1);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -883,6 +963,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 1, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -953,7 +1069,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 1);
@@ -1273,6 +1390,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 2, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -1298,7 +1455,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 2);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -1308,19 +1465,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 2);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 2, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 2);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 2);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 2);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -1335,7 +1492,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 2);
@@ -1370,7 +1528,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 2);
+                pos_args = MAKE_TUPLE(tstate, args, 2);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -1442,7 +1600,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 2);
+                            pos_args = MAKE_TUPLE(tstate, args, 2);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -1541,7 +1699,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 2);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -1666,6 +1824,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 2, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -1720,7 +1914,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 2);
@@ -2033,6 +2228,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 3, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -2058,7 +2293,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 3);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -2068,19 +2303,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 3);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 3, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 3);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 3);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 3);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -2095,7 +2330,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 3);
@@ -2130,7 +2366,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 3);
+                pos_args = MAKE_TUPLE(tstate, args, 3);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -2202,7 +2438,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 3);
+                            pos_args = MAKE_TUPLE(tstate, args, 3);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -2301,7 +2537,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 3);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -2426,6 +2662,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 3, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -2480,7 +2752,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 3);
@@ -2793,6 +3066,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 4, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -2818,7 +3131,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 4);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -2828,19 +3141,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 4);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 4, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 4);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 4);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 4);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -2855,7 +3168,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 4);
@@ -2890,7 +3204,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 4);
+                pos_args = MAKE_TUPLE(tstate, args, 4);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -2962,7 +3276,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 4);
+                            pos_args = MAKE_TUPLE(tstate, args, 4);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -3061,7 +3375,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 4);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -3186,8 +3500,44 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
-        // Try to be fast about wrapping the arguments.
-        int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 4, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
+        // Try to be fast about wrapping the arguments.
+        int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
         if (unlikely(flags & METH_NOARGS)) {
             SET_CURRENT_EXCEPTION_TYPE0_FORMAT1(PyExc_TypeError, "%s() takes no arguments (4 given)",
@@ -3240,7 +3590,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 4);
@@ -3553,6 +3904,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 5, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -3578,7 +3969,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 5);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -3588,19 +3979,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 5);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 5, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 5);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 5);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 5);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -3615,7 +4006,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 5);
@@ -3650,7 +4042,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 5);
+                pos_args = MAKE_TUPLE(tstate, args, 5);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -3722,7 +4114,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 5);
+                            pos_args = MAKE_TUPLE(tstate, args, 5);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -3821,7 +4213,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 5);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -3946,6 +4338,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 5, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -4000,7 +4428,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 5);
@@ -4313,6 +4742,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 6, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -4338,7 +4807,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 6);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -4348,19 +4817,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 6);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 6, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 6);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 6);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 6);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -4375,7 +4844,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 6);
@@ -4410,7 +4880,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 6);
+                pos_args = MAKE_TUPLE(tstate, args, 6);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -4482,7 +4952,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 6);
+                            pos_args = MAKE_TUPLE(tstate, args, 6);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -4581,7 +5051,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 6);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -4706,6 +5176,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 6, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -4760,7 +5266,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 6);
@@ -5073,6 +5580,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 7, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -5098,7 +5645,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 7);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -5108,19 +5655,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 7);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 7, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 7);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 7);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 7);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -5135,7 +5682,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 7);
@@ -5170,7 +5718,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 7);
+                pos_args = MAKE_TUPLE(tstate, args, 7);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -5242,7 +5790,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 7);
+                            pos_args = MAKE_TUPLE(tstate, args, 7);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -5341,7 +5889,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 7);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -5466,6 +6014,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 7, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -5520,7 +6104,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 7);
@@ -5833,6 +6418,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 8, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -5858,7 +6483,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 8);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -5868,19 +6493,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 8);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 8, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 8);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 8);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 8);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -5895,7 +6520,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 8);
@@ -5930,7 +6556,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 8);
+                pos_args = MAKE_TUPLE(tstate, args, 8);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -6002,7 +6628,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 8);
+                            pos_args = MAKE_TUPLE(tstate, args, 8);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -6101,7 +6727,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 8);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -6226,6 +6852,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 8, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -6280,7 +6942,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 8);
@@ -6593,6 +7256,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 9, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -6618,7 +7321,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 9);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -6628,19 +7331,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 9);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 9, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 9);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 9);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 9);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -6655,7 +7358,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 9);
@@ -6690,7 +7394,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 9);
+                pos_args = MAKE_TUPLE(tstate, args, 9);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -6762,7 +7466,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 9);
+                            pos_args = MAKE_TUPLE(tstate, args, 9);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -6861,7 +7565,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyOb
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 9);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -6986,6 +7690,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9(PyThreadState *tstate, PyObject *called, P
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 9, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -7040,7 +7780,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9(PyThreadState *tstate, PyObject *called, P
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 9);
@@ -7353,6 +8094,46 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 10, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+            Py_DECREF(pos_args);
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -7378,7 +8159,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
             PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-            PyObject *pos_args = MAKE_TUPLE(args, 10);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
             if (flags & METH_KEYWORDS) {
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             } else {
@@ -7388,19 +8169,19 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
             Py_DECREF(pos_args);
 #else
             if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-                PyObject *pos_args = MAKE_TUPLE(args, 10);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
                 result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
                 Py_DECREF(pos_args);
             } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
                 result = (*(_PyCFunctionFast)method)(self, (PyObject **)args, 10, NULL);
 #else
-                PyObject *pos_args = MAKE_TUPLE(args, 10);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
                 result = (*(_PyCFunctionFast)method)(self, &pos_args, 10);
                 Py_DECREF(pos_args);
 #endif
             } else {
-                PyObject *pos_args = MAKE_TUPLE(args, 10);
+                PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
                 result = (*method)(self, pos_args);
                 Py_DECREF(pos_args);
             }
@@ -7415,7 +8196,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 10);
@@ -7450,7 +8232,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
                 obj = called_type->tp_alloc(called_type, 0);
                 CHECK_OBJECT(obj);
             } else {
-                pos_args = MAKE_TUPLE(args, 10);
+                pos_args = MAKE_TUPLE(tstate, args, 10);
                 obj = called_type->tp_new(called_type, pos_args, NULL);
             }
 
@@ -7522,7 +8304,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
                         }
                     } else {
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, 10);
+                            pos_args = MAKE_TUPLE(tstate, args, 10);
                         }
 
                         if (unlikely(type->tp_init(obj, pos_args, NULL) < 0)) {
@@ -7621,7 +8403,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyO
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 10);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -7746,6 +8528,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10(PyThreadState *tstate, PyObject *called,
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+            result = func(called, args, 10, NULL);
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -7800,7 +8618,8 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10(PyThreadState *tstate, PyObject *called,
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
         PyObject *result = callPythonFunction(called, args, 10);
@@ -8141,7 +8960,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS1_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 1);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -8229,7 +9048,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS1_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 1);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -8400,7 +9219,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 2);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -8488,7 +9307,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 2);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -8659,7 +9478,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 3);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -8747,7 +9566,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 3);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -8918,7 +9737,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 4);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9006,7 +9825,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 4);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9177,7 +9996,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 5);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9265,7 +10084,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 5);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 5);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9436,7 +10255,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 6);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9524,7 +10343,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 6);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 6);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9695,7 +10514,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 7);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9783,7 +10602,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 7);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 7);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -9954,7 +10773,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 8);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -10042,7 +10861,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 8);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 8);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -10213,7 +11032,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9_VECTORCALL(PyThreadState *tstate, PyObject *c
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 9);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -10301,7 +11120,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9_KWSPLIT(PyThreadState *tstate, PyObject *call
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 9);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 9);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -10472,7 +11291,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10_VECTORCALL(PyThreadState *tstate, PyObject *
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 10);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -10560,7 +11379,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10_KWSPLIT(PyThreadState *tstate, PyObject *cal
         return NULL;
     }
 
-    PyObject *pos_args = MAKE_TUPLE(args, 10);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 10);
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);
 
@@ -10718,7 +11537,7 @@ PyObject *CALL_METHODDESCR_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *call
         PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-        PyObject *pos_args = MAKE_TUPLE(args + 1, 0);
+        PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 0);
 
         if (flags & METH_KEYWORDS) {
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
@@ -10729,19 +11548,19 @@ PyObject *CALL_METHODDESCR_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *call
         Py_DECREF(pos_args);
 #else
         if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 0);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 0);
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             Py_DECREF(pos_args);
         } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
             result = (*(_PyCFunctionFast)method)(self, (PyObject **)args + 1, 0, NULL);
 #else
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 0);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 0);
             result = (*(_PyCFunctionFast)method)(self, &pos_args, 1);
             Py_DECREF(pos_args);
 #endif
         } else {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 0);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 0);
             result = (*method)(self, pos_args);
             Py_DECREF(pos_args);
         }
@@ -10760,7 +11579,7 @@ PyObject *CALL_METHODDESCR_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *call
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 1);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 1);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -10820,7 +11639,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS2(PyThreadState *tstate, PyObject *called, P
         PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-        PyObject *pos_args = MAKE_TUPLE(args + 1, 1);
+        PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 1);
 
         if (flags & METH_KEYWORDS) {
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
@@ -10831,19 +11650,19 @@ PyObject *CALL_METHODDESCR_WITH_ARGS2(PyThreadState *tstate, PyObject *called, P
         Py_DECREF(pos_args);
 #else
         if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 1);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 1);
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             Py_DECREF(pos_args);
         } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
             result = (*(_PyCFunctionFast)method)(self, (PyObject **)args + 1, 1, NULL);
 #else
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 1);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 1);
             result = (*(_PyCFunctionFast)method)(self, &pos_args, 2);
             Py_DECREF(pos_args);
 #endif
         } else {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 1);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 1);
             result = (*method)(self, pos_args);
             Py_DECREF(pos_args);
         }
@@ -10862,7 +11681,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS2(PyThreadState *tstate, PyObject *called, P
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 2);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 2);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -10915,7 +11734,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS3(PyThreadState *tstate, PyObject *called, P
         PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-        PyObject *pos_args = MAKE_TUPLE(args + 1, 2);
+        PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 2);
 
         if (flags & METH_KEYWORDS) {
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
@@ -10926,19 +11745,19 @@ PyObject *CALL_METHODDESCR_WITH_ARGS3(PyThreadState *tstate, PyObject *called, P
         Py_DECREF(pos_args);
 #else
         if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 2);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 2);
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             Py_DECREF(pos_args);
         } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
             result = (*(_PyCFunctionFast)method)(self, (PyObject **)args + 1, 2, NULL);
 #else
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 2);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 2);
             result = (*(_PyCFunctionFast)method)(self, &pos_args, 3);
             Py_DECREF(pos_args);
 #endif
         } else {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 2);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 2);
             result = (*method)(self, pos_args);
             Py_DECREF(pos_args);
         }
@@ -10957,7 +11776,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS3(PyThreadState *tstate, PyObject *called, P
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 3);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 3);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);
 
@@ -11010,7 +11829,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS4(PyThreadState *tstate, PyObject *called, P
         PyObject *result;
 
 #if PYTHON_VERSION < 0x360
-        PyObject *pos_args = MAKE_TUPLE(args + 1, 3);
+        PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 3);
 
         if (flags & METH_KEYWORDS) {
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
@@ -11021,19 +11840,19 @@ PyObject *CALL_METHODDESCR_WITH_ARGS4(PyThreadState *tstate, PyObject *called, P
         Py_DECREF(pos_args);
 #else
         if (flags == (METH_VARARGS | METH_KEYWORDS)) {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 3);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 3);
             result = (*(PyCFunctionWithKeywords)method)(self, pos_args, NULL);
             Py_DECREF(pos_args);
         } else if (flags == METH_FASTCALL) {
 #if PYTHON_VERSION < 0x370
             result = (*(_PyCFunctionFast)method)(self, (PyObject **)args + 1, 3, NULL);
 #else
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 3);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 3);
             result = (*(_PyCFunctionFast)method)(self, &pos_args, 4);
             Py_DECREF(pos_args);
 #endif
         } else {
-            PyObject *pos_args = MAKE_TUPLE(args + 1, 3);
+            PyObject *pos_args = MAKE_TUPLE(tstate, args + 1, 3);
             result = (*method)(self, pos_args);
             Py_DECREF(pos_args);
         }
@@ -11052,7 +11871,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS4(PyThreadState *tstate, PyObject *called, P
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *pos_args = MAKE_TUPLE(args, 4);
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, 4);
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);