Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersCallingGenerated.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* WARNING, this code is GENERATED. Modify the template CodeTemplateCallsPositional.c.j2 instead! */
 
 /* This file is included from another C file, help IDEs to still parse it on its own. */
@@ -105,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);
 
@@ -178,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);
@@ -486,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);
 
@@ -527,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 {
@@ -537,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);
             }
@@ -564,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);
@@ -605,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);
             }
 
@@ -678,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)) {
@@ -777,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);
 
@@ -898,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);
 
@@ -968,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);
@@ -1288,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);
 
@@ -1313,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 {
@@ -1323,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);
             }
@@ -1350,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);
@@ -1385,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);
             }
 
@@ -1457,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)) {
@@ -1556,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);
 
@@ -1681,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);
 
@@ -1735,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);
@@ -2048,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);
 
@@ -2073,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 {
@@ -2083,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);
             }
@@ -2110,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);
@@ -2145,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);
             }
 
@@ -2217,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)) {
@@ -2316,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);
 
@@ -2441,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);
 
@@ -2495,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);
@@ -2808,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);
 
@@ -2833,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 {
@@ -2843,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);
             }
@@ -2870,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);
@@ -2905,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);
             }
 
@@ -2977,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)) {
@@ -3076,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);
 
@@ -3201,6 +3500,42 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(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, 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);
 
@@ -3255,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);
@@ -3568,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);
 
@@ -3593,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 {
@@ -3603,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);
             }
@@ -3630,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);
@@ -3665,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);
             }
 
@@ -3737,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)) {
@@ -3836,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);
 
@@ -3961,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);
 
@@ -4015,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);
@@ -4328,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);
 
@@ -4353,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 {
@@ -4363,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);
             }
@@ -4390,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);
@@ -4425,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);
             }
 
@@ -4497,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)) {
@@ -4596,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);
 
@@ -4721,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);
 
@@ -4775,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);
@@ -5071,23 +5563,63 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyOb
                 memcpy(python_pars + 1 + 7, &PyTuple_GET_ITEM(function->m_defaults, 0),
                        function->m_defaults_given * sizeof(PyObject *));
 
-                for (Py_ssize_t i = 1; i < function->m_args_overall_count; i++) {
-                    Py_INCREF(python_pars[i]);
-                }
+                for (Py_ssize_t i = 1; i < function->m_args_overall_count; i++) {
+                    Py_INCREF(python_pars[i]);
+                }
+
+                result = function->m_c_code(tstate, function, python_pars);
+            } else {
+                result = Nuitka_CallMethodFunctionPosArgs(tstate, function, method->m_object, args, 7);
+            }
+
+            Py_LeaveRecursiveCall();
+
+            CHECK_OBJECT_X(result);
+
+            return result;
+        }
+#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);
 
-                result = function->m_c_code(tstate, function, python_pars);
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void (*)(void))method)(self, pos_args, NULL);
             } else {
-                result = Nuitka_CallMethodFunctionPosArgs(tstate, function, method->m_object, args, 7);
+                result = (*method)(self, pos_args);
             }
 
-            Py_LeaveRecursiveCall();
+            Py_DECREF(pos_args);
+        }
 
-            CHECK_OBJECT_X(result);
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
 
-            return result;
-        }
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
-    } else if (PyCFunction_CheckExact(called)) {
+        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);
 
@@ -5113,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 {
@@ -5123,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);
             }
@@ -5150,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);
@@ -5185,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);
             }
 
@@ -5257,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)) {
@@ -5356,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);
 
@@ -5481,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);
 
@@ -5535,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);
@@ -5848,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);
 
@@ -5873,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 {
@@ -5883,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);
             }
@@ -5910,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);
@@ -5945,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);
             }
 
@@ -6017,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)) {
@@ -6116,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);
 
@@ -6241,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);
 
@@ -6295,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);
@@ -6608,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);
 
@@ -6633,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 {
@@ -6643,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);
             }
@@ -6670,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);
@@ -6705,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);
             }
 
@@ -6777,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)) {
@@ -6876,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);
 
@@ -7001,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);
 
@@ -7055,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);
@@ -7368,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);
 
@@ -7393,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 {
@@ -7403,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);
             }
@@ -7430,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);
@@ -7465,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);
             }
 
@@ -7537,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)) {
@@ -7636,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);
 
@@ -7761,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);
 
@@ -7815,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);
@@ -8156,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);
 
@@ -8244,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);
 
@@ -8415,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);
 
@@ -8503,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);
 
@@ -8674,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);
 
@@ -8762,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);
 
@@ -8933,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);
 
@@ -9021,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);
 
@@ -9192,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);
 
@@ -9280,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);
 
@@ -9451,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);
 
@@ -9539,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);
 
@@ -9710,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);
 
@@ -9798,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);
 
@@ -9969,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);
 
@@ -10057,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);
 
@@ -10228,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);
 
@@ -10316,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);
 
@@ -10487,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);
 
@@ -10575,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);
 
@@ -10733,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);
@@ -10744,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);
         }
@@ -10775,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);
 
@@ -10835,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);
@@ -10846,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);
         }
@@ -10877,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);
 
@@ -10930,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);
@@ -10941,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);
         }
@@ -10972,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);
 
@@ -11025,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);
@@ -11036,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);
         }
@@ -11067,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);
 
@@ -11099,7 +11903,7 @@ PyObject *CALL_METHOD_NO_ARGS(PyThreadState *tstate, PyObject *source, PyObject
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -11265,7 +12069,7 @@ PyObject *CALL_METHOD_NO_ARGS(PyThreadState *tstate, PyObject *source, PyObject
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -11325,7 +12129,7 @@ PyObject *CALL_METHOD_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *source, P
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -11491,7 +12295,7 @@ PyObject *CALL_METHOD_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *source, P
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -11550,7 +12354,7 @@ PyObject *CALL_METHOD_WITH_ARGS2(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -11716,7 +12520,7 @@ PyObject *CALL_METHOD_WITH_ARGS2(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -11775,7 +12579,7 @@ PyObject *CALL_METHOD_WITH_ARGS3(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -11941,7 +12745,7 @@ PyObject *CALL_METHOD_WITH_ARGS3(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -12000,7 +12804,7 @@ PyObject *CALL_METHOD_WITH_ARGS4(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -12166,7 +12970,7 @@ PyObject *CALL_METHOD_WITH_ARGS4(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -12225,7 +13029,7 @@ PyObject *CALL_METHOD_WITH_ARGS5(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -12391,7 +13195,7 @@ PyObject *CALL_METHOD_WITH_ARGS5(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -12450,7 +13254,7 @@ PyObject *CALL_METHOD_WITH_ARGS6(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -12616,7 +13420,7 @@ PyObject *CALL_METHOD_WITH_ARGS6(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -12675,7 +13479,7 @@ PyObject *CALL_METHOD_WITH_ARGS7(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -12841,7 +13645,7 @@ PyObject *CALL_METHOD_WITH_ARGS7(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -12900,7 +13704,7 @@ PyObject *CALL_METHOD_WITH_ARGS8(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -13066,7 +13870,7 @@ PyObject *CALL_METHOD_WITH_ARGS8(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -13125,7 +13929,7 @@ PyObject *CALL_METHOD_WITH_ARGS9(PyThreadState *tstate, PyObject *source, PyObje
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -13291,7 +14095,7 @@ PyObject *CALL_METHOD_WITH_ARGS9(PyThreadState *tstate, PyObject *source, PyObje
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -13350,7 +14154,7 @@ PyObject *CALL_METHOD_WITH_ARGS10(PyThreadState *tstate, PyObject *source, PyObj
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -13516,7 +14320,7 @@ PyObject *CALL_METHOD_WITH_ARGS10(PyThreadState *tstate, PyObject *source, PyObj
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -13550,3 +14354,18 @@ PyObject *CALL_METHOD_WITH_ARGS10(PyThreadState *tstate, PyObject *source, PyObj
         return NULL;
     }
 }
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.