Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 1910 insertions, 1910 deletions

diff --git a/contrib/tools/python3/src/Python/ceval.c b/contrib/tools/python3/src/Python/ceval.c
index e07adf6e19..9a61f8a3c3 100644
--- a/contrib/tools/python3/src/Python/ceval.c
+++ b/contrib/tools/python3/src/Python/ceval.c
@@ -10,18 +10,18 @@
 #define PY_LOCAL_AGGRESSIVE
 
 #include "Python.h"
-#include "pycore_abstract.h"      // _PyIndex_Check() 
-#include "pycore_call.h" 
-#include "pycore_ceval.h" 
-#include "pycore_code.h" 
-#include "pycore_initconfig.h" 
-#include "pycore_object.h" 
-#include "pycore_pyerrors.h" 
-#include "pycore_pylifecycle.h" 
-#include "pycore_pymem.h"         // _PyMem_IsPtrFreed() 
-#include "pycore_pystate.h"       // _PyInterpreterState_GET() 
-#include "pycore_sysmodule.h" 
-#include "pycore_tupleobject.h" 
+#include "pycore_abstract.h"      // _PyIndex_Check()
+#include "pycore_call.h"
+#include "pycore_ceval.h"
+#include "pycore_code.h"
+#include "pycore_initconfig.h"
+#include "pycore_object.h"
+#include "pycore_pyerrors.h"
+#include "pycore_pylifecycle.h"
+#include "pycore_pymem.h"         // _PyMem_IsPtrFreed()
+#include "pycore_pystate.h"       // _PyInterpreterState_GET()
+#include "pycore_sysmodule.h"
+#include "pycore_tupleobject.h"
 
 #include "code.h"
 #include "dictobject.h"
@@ -38,23 +38,23 @@
 #define CHECKEXC 1      /* Double-check exception checking */
 #endif
 
-#if !defined(Py_BUILD_CORE) 
-#  error "ceval.c must be build with Py_BUILD_CORE define for best performance" 
-#endif 
- 
-_Py_IDENTIFIER(__name__); 
+#if !defined(Py_BUILD_CORE)
+#  error "ceval.c must be build with Py_BUILD_CORE define for best performance"
+#endif
+
+_Py_IDENTIFIER(__name__);
 
 /* Forward declarations */
-Py_LOCAL_INLINE(PyObject *) call_function( 
-    PyThreadState *tstate, PyObject ***pp_stack, 
-    Py_ssize_t oparg, PyObject *kwnames); 
-static PyObject * do_call_core( 
-    PyThreadState *tstate, PyObject *func, 
-    PyObject *callargs, PyObject *kwdict); 
+Py_LOCAL_INLINE(PyObject *) call_function(
+    PyThreadState *tstate, PyObject ***pp_stack,
+    Py_ssize_t oparg, PyObject *kwnames);
+static PyObject * do_call_core(
+    PyThreadState *tstate, PyObject *func,
+    PyObject *callargs, PyObject *kwdict);
 
 #ifdef LLTRACE
 static int lltrace;
-static int prtrace(PyThreadState *, PyObject *, const char *); 
+static int prtrace(PyThreadState *, PyObject *, const char *);
 #endif
 static int call_trace(Py_tracefunc, PyObject *,
                       PyThreadState *, PyFrameObject *,
@@ -71,18 +71,18 @@ static void maybe_dtrace_line(PyFrameObject *, int *, int *, int *);
 static void dtrace_function_entry(PyFrameObject *);
 static void dtrace_function_return(PyFrameObject *);
 
-static PyObject * import_name(PyThreadState *, PyFrameObject *, 
-                              PyObject *, PyObject *, PyObject *); 
-static PyObject * import_from(PyThreadState *, PyObject *, PyObject *); 
-static int import_all_from(PyThreadState *, PyObject *, PyObject *); 
-static void format_exc_check_arg(PyThreadState *, PyObject *, const char *, PyObject *); 
-static void format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg); 
-static PyObject * unicode_concatenate(PyThreadState *, PyObject *, PyObject *, 
+static PyObject * import_name(PyThreadState *, PyFrameObject *,
+                              PyObject *, PyObject *, PyObject *);
+static PyObject * import_from(PyThreadState *, PyObject *, PyObject *);
+static int import_all_from(PyThreadState *, PyObject *, PyObject *);
+static void format_exc_check_arg(PyThreadState *, PyObject *, const char *, PyObject *);
+static void format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg);
+static PyObject * unicode_concatenate(PyThreadState *, PyObject *, PyObject *,
                                       PyFrameObject *, const _Py_CODEUNIT *);
-static PyObject * special_lookup(PyThreadState *, PyObject *, _Py_Identifier *); 
-static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg); 
-static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwargs); 
-static void format_awaitable_error(PyThreadState *, PyTypeObject *, int, int); 
+static PyObject * special_lookup(PyThreadState *, PyObject *, _Py_Identifier *);
+static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg);
+static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwargs);
+static void format_awaitable_error(PyThreadState *, PyTypeObject *, int, int);
 
 #define NAME_ERROR_MSG \
     "name '%.200s' is not defined"
@@ -102,372 +102,372 @@ static long dxp[256];
 #endif
 #endif
 
-/* per opcode cache */ 
-#ifdef Py_DEBUG 
-// --with-pydebug is used to find memory leak.  opcache makes it harder. 
-// So we disable opcache when Py_DEBUG is defined. 
-// See bpo-37146 
-#define OPCACHE_MIN_RUNS 0  /* disable opcache */ 
-#else 
-#define OPCACHE_MIN_RUNS 1024  /* create opcache when code executed this time */ 
-#endif 
-#define OPCACHE_STATS 0  /* Enable stats */ 
-
-#if OPCACHE_STATS 
-static size_t opcache_code_objects = 0; 
-static size_t opcache_code_objects_extra_mem = 0; 
- 
-static size_t opcache_global_opts = 0; 
-static size_t opcache_global_hits = 0; 
-static size_t opcache_global_misses = 0; 
-#endif 
- 
- 
-#ifndef NDEBUG 
-/* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and 
-   PyEval_RestoreThread(). Detect if tstate memory was freed. It can happen 
-   when a thread continues to run after Python finalization, especially 
-   daemon threads. */ 
-static int 
-is_tstate_valid(PyThreadState *tstate) 
-{ 
-    assert(!_PyMem_IsPtrFreed(tstate)); 
-    assert(!_PyMem_IsPtrFreed(tstate->interp)); 
-    return 1; 
-} 
-#endif 
- 
- 
+/* per opcode cache */
+#ifdef Py_DEBUG
+// --with-pydebug is used to find memory leak.  opcache makes it harder.
+// So we disable opcache when Py_DEBUG is defined.
+// See bpo-37146
+#define OPCACHE_MIN_RUNS 0  /* disable opcache */
+#else
+#define OPCACHE_MIN_RUNS 1024  /* create opcache when code executed this time */
+#endif
+#define OPCACHE_STATS 0  /* Enable stats */
+
+#if OPCACHE_STATS
+static size_t opcache_code_objects = 0;
+static size_t opcache_code_objects_extra_mem = 0;
+
+static size_t opcache_global_opts = 0;
+static size_t opcache_global_hits = 0;
+static size_t opcache_global_misses = 0;
+#endif
+
+
+#ifndef NDEBUG
+/* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and
+   PyEval_RestoreThread(). Detect if tstate memory was freed. It can happen
+   when a thread continues to run after Python finalization, especially
+   daemon threads. */
+static int
+is_tstate_valid(PyThreadState *tstate)
+{
+    assert(!_PyMem_IsPtrFreed(tstate));
+    assert(!_PyMem_IsPtrFreed(tstate->interp));
+    return 1;
+}
+#endif
+
+
 /* This can set eval_breaker to 0 even though gil_drop_request became
    1.  We believe this is all right because the eval loop will release
    the GIL eventually anyway. */
-static inline void 
-COMPUTE_EVAL_BREAKER(PyInterpreterState *interp, 
-                     struct _ceval_runtime_state *ceval, 
-                     struct _ceval_state *ceval2) 
-{ 
-    _Py_atomic_store_relaxed(&ceval2->eval_breaker, 
-        _Py_atomic_load_relaxed(&ceval2->gil_drop_request) 
-        | (_Py_atomic_load_relaxed(&ceval->signals_pending) 
-           && _Py_ThreadCanHandleSignals(interp)) 
-        | (_Py_atomic_load_relaxed(&ceval2->pending.calls_to_do) 
-           && _Py_ThreadCanHandlePendingCalls()) 
-        | ceval2->pending.async_exc); 
-} 
-
-
-static inline void 
-SET_GIL_DROP_REQUEST(PyInterpreterState *interp) 
-{ 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 1); 
-    _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1); 
-} 
-
-
-static inline void 
-RESET_GIL_DROP_REQUEST(PyInterpreterState *interp) 
-{ 
-    struct _ceval_runtime_state *ceval = &interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 0); 
-    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2); 
-} 
-
-
-static inline void 
-SIGNAL_PENDING_CALLS(PyInterpreterState *interp) 
-{ 
-    struct _ceval_runtime_state *ceval = &interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 1); 
-    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2); 
-} 
-
-
-static inline void 
-UNSIGNAL_PENDING_CALLS(PyInterpreterState *interp) 
-{ 
-    struct _ceval_runtime_state *ceval = &interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 0); 
-    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2); 
-} 
- 
- 
-static inline void 
-SIGNAL_PENDING_SIGNALS(PyInterpreterState *interp, int force) 
-{ 
-    struct _ceval_runtime_state *ceval = &interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    _Py_atomic_store_relaxed(&ceval->signals_pending, 1); 
-    if (force) { 
-        _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1); 
-    } 
-    else { 
-        /* eval_breaker is not set to 1 if thread_can_handle_signals() is false */ 
-        COMPUTE_EVAL_BREAKER(interp, ceval, ceval2); 
-    } 
-} 
- 
- 
-static inline void 
-UNSIGNAL_PENDING_SIGNALS(PyInterpreterState *interp) 
-{ 
-    struct _ceval_runtime_state *ceval = &interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    _Py_atomic_store_relaxed(&ceval->signals_pending, 0); 
-    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2); 
-} 
- 
- 
-static inline void 
-SIGNAL_ASYNC_EXC(PyInterpreterState *interp) 
-{ 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    ceval2->pending.async_exc = 1; 
-    _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1); 
-} 
- 
- 
-static inline void 
-UNSIGNAL_ASYNC_EXC(PyInterpreterState *interp) 
-{ 
-    struct _ceval_runtime_state *ceval = &interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &interp->ceval; 
-    ceval2->pending.async_exc = 0; 
-    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2); 
-} 
- 
- 
+static inline void
+COMPUTE_EVAL_BREAKER(PyInterpreterState *interp,
+                     struct _ceval_runtime_state *ceval,
+                     struct _ceval_state *ceval2)
+{
+    _Py_atomic_store_relaxed(&ceval2->eval_breaker,
+        _Py_atomic_load_relaxed(&ceval2->gil_drop_request)
+        | (_Py_atomic_load_relaxed(&ceval->signals_pending)
+           && _Py_ThreadCanHandleSignals(interp))
+        | (_Py_atomic_load_relaxed(&ceval2->pending.calls_to_do)
+           && _Py_ThreadCanHandlePendingCalls())
+        | ceval2->pending.async_exc);
+}
+
+
+static inline void
+SET_GIL_DROP_REQUEST(PyInterpreterState *interp)
+{
+    struct _ceval_state *ceval2 = &interp->ceval;
+    _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 1);
+    _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);
+}
+
+
+static inline void
+RESET_GIL_DROP_REQUEST(PyInterpreterState *interp)
+{
+    struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &interp->ceval;
+    _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 0);
+    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
+}
+
+
+static inline void
+SIGNAL_PENDING_CALLS(PyInterpreterState *interp)
+{
+    struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &interp->ceval;
+    _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 1);
+    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
+}
+
+
+static inline void
+UNSIGNAL_PENDING_CALLS(PyInterpreterState *interp)
+{
+    struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &interp->ceval;
+    _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 0);
+    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
+}
+
+
+static inline void
+SIGNAL_PENDING_SIGNALS(PyInterpreterState *interp, int force)
+{
+    struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &interp->ceval;
+    _Py_atomic_store_relaxed(&ceval->signals_pending, 1);
+    if (force) {
+        _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);
+    }
+    else {
+        /* eval_breaker is not set to 1 if thread_can_handle_signals() is false */
+        COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
+    }
+}
+
+
+static inline void
+UNSIGNAL_PENDING_SIGNALS(PyInterpreterState *interp)
+{
+    struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &interp->ceval;
+    _Py_atomic_store_relaxed(&ceval->signals_pending, 0);
+    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
+}
+
+
+static inline void
+SIGNAL_ASYNC_EXC(PyInterpreterState *interp)
+{
+    struct _ceval_state *ceval2 = &interp->ceval;
+    ceval2->pending.async_exc = 1;
+    _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);
+}
+
+
+static inline void
+UNSIGNAL_ASYNC_EXC(PyInterpreterState *interp)
+{
+    struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &interp->ceval;
+    ceval2->pending.async_exc = 0;
+    COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
+}
+
+
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
 #endif
 #include "ceval_gil.h"
 
-void _Py_NO_RETURN 
-_Py_FatalError_TstateNULL(const char *func) 
-{ 
-    _Py_FatalErrorFunc(func, 
-                       "the function must be called with the GIL held, " 
-                       "but the GIL is released " 
-                       "(the current Python thread state is NULL)"); 
-} 
- 
- 
+void _Py_NO_RETURN
+_Py_FatalError_TstateNULL(const char *func)
+{
+    _Py_FatalErrorFunc(func,
+                       "the function must be called with the GIL held, "
+                       "but the GIL is released "
+                       "(the current Python thread state is NULL)");
+}
+
+
+int
+_PyEval_ThreadsInitialized(_PyRuntimeState *runtime)
+{
+    return gil_created(&runtime->ceval.gil);
+}
+
 int
-_PyEval_ThreadsInitialized(_PyRuntimeState *runtime) 
-{ 
-    return gil_created(&runtime->ceval.gil); 
-} 
- 
-int 
 PyEval_ThreadsInitialized(void)
 {
-    _PyRuntimeState *runtime = &_PyRuntime; 
-    return _PyEval_ThreadsInitialized(runtime); 
+    _PyRuntimeState *runtime = &_PyRuntime;
+    return _PyEval_ThreadsInitialized(runtime);
 }
 
-PyStatus 
-_PyEval_InitGIL(PyThreadState *tstate) 
+PyStatus
+_PyEval_InitGIL(PyThreadState *tstate)
 {
-    if (!_Py_IsMainInterpreter(tstate)) { 
-        /* Currently, the GIL is shared by all interpreters, 
-           and only the main interpreter is responsible to create 
-           and destroy it. */ 
-        return _PyStatus_OK(); 
-    } 
- 
-    struct _gil_runtime_state *gil = &tstate->interp->runtime->ceval.gil; 
-    assert(!gil_created(gil)); 
- 
-    PyThread_init_thread(); 
-    create_gil(gil); 
- 
-    take_gil(tstate); 
- 
-    assert(gil_created(gil)); 
-    return _PyStatus_OK(); 
+    if (!_Py_IsMainInterpreter(tstate)) {
+        /* Currently, the GIL is shared by all interpreters,
+           and only the main interpreter is responsible to create
+           and destroy it. */
+        return _PyStatus_OK();
+    }
+
+    struct _gil_runtime_state *gil = &tstate->interp->runtime->ceval.gil;
+    assert(!gil_created(gil));
+
+    PyThread_init_thread();
+    create_gil(gil);
+
+    take_gil(tstate);
+
+    assert(gil_created(gil));
+    return _PyStatus_OK();
 }
 
 void
-_PyEval_FiniGIL(PyThreadState *tstate) 
+_PyEval_FiniGIL(PyThreadState *tstate)
 {
-    if (!_Py_IsMainInterpreter(tstate)) { 
-        /* Currently, the GIL is shared by all interpreters, 
-           and only the main interpreter is responsible to create 
-           and destroy it. */ 
-        return; 
-    } 
- 
-    struct _gil_runtime_state *gil = &tstate->interp->runtime->ceval.gil; 
-    if (!gil_created(gil)) { 
-        /* First Py_InitializeFromConfig() call: the GIL doesn't exist 
-           yet: do nothing. */ 
+    if (!_Py_IsMainInterpreter(tstate)) {
+        /* Currently, the GIL is shared by all interpreters,
+           and only the main interpreter is responsible to create
+           and destroy it. */
         return;
-    } 
- 
-    destroy_gil(gil); 
-    assert(!gil_created(gil)); 
+    }
+
+    struct _gil_runtime_state *gil = &tstate->interp->runtime->ceval.gil;
+    if (!gil_created(gil)) {
+        /* First Py_InitializeFromConfig() call: the GIL doesn't exist
+           yet: do nothing. */
+        return;
+    }
+
+    destroy_gil(gil);
+    assert(!gil_created(gil));
+}
+
+void
+PyEval_InitThreads(void)
+{
+    /* Do nothing: kept for backward compatibility */
+}
+
+void
+_PyEval_Fini(void)
+{
+#if OPCACHE_STATS
+    fprintf(stderr, "-- Opcode cache number of objects  = %zd\n",
+            opcache_code_objects);
+
+    fprintf(stderr, "-- Opcode cache total extra mem    = %zd\n",
+            opcache_code_objects_extra_mem);
+
+    fprintf(stderr, "\n");
+
+    fprintf(stderr, "-- Opcode cache LOAD_GLOBAL hits   = %zd (%d%%)\n",
+            opcache_global_hits,
+            (int) (100.0 * opcache_global_hits /
+                (opcache_global_hits + opcache_global_misses)));
+
+    fprintf(stderr, "-- Opcode cache LOAD_GLOBAL misses = %zd (%d%%)\n",
+            opcache_global_misses,
+            (int) (100.0 * opcache_global_misses /
+                (opcache_global_hits + opcache_global_misses)));
+
+    fprintf(stderr, "-- Opcode cache LOAD_GLOBAL opts   = %zd\n",
+            opcache_global_opts);
+
+    fprintf(stderr, "\n");
+#endif
 }
 
-void 
-PyEval_InitThreads(void) 
-{ 
-    /* Do nothing: kept for backward compatibility */ 
-} 
- 
 void
-_PyEval_Fini(void) 
-{ 
-#if OPCACHE_STATS 
-    fprintf(stderr, "-- Opcode cache number of objects  = %zd\n", 
-            opcache_code_objects); 
- 
-    fprintf(stderr, "-- Opcode cache total extra mem    = %zd\n", 
-            opcache_code_objects_extra_mem); 
- 
-    fprintf(stderr, "\n"); 
- 
-    fprintf(stderr, "-- Opcode cache LOAD_GLOBAL hits   = %zd (%d%%)\n", 
-            opcache_global_hits, 
-            (int) (100.0 * opcache_global_hits / 
-                (opcache_global_hits + opcache_global_misses))); 
- 
-    fprintf(stderr, "-- Opcode cache LOAD_GLOBAL misses = %zd (%d%%)\n", 
-            opcache_global_misses, 
-            (int) (100.0 * opcache_global_misses / 
-                (opcache_global_hits + opcache_global_misses))); 
- 
-    fprintf(stderr, "-- Opcode cache LOAD_GLOBAL opts   = %zd\n", 
-            opcache_global_opts); 
- 
-    fprintf(stderr, "\n"); 
-#endif 
-} 
- 
-void 
 PyEval_AcquireLock(void)
 {
-    _PyRuntimeState *runtime = &_PyRuntime; 
-    PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime); 
-    _Py_EnsureTstateNotNULL(tstate); 
- 
-    take_gil(tstate); 
+    _PyRuntimeState *runtime = &_PyRuntime;
+    PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
+    _Py_EnsureTstateNotNULL(tstate);
+
+    take_gil(tstate);
 }
 
 void
 PyEval_ReleaseLock(void)
 {
-    _PyRuntimeState *runtime = &_PyRuntime; 
-    PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime); 
+    _PyRuntimeState *runtime = &_PyRuntime;
+    PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
     /* This function must succeed when the current thread state is NULL.
-       We therefore avoid PyThreadState_Get() which dumps a fatal error 
-       in debug mode. */ 
-    struct _ceval_runtime_state *ceval = &runtime->ceval; 
-    struct _ceval_state *ceval2 = &tstate->interp->ceval; 
-    drop_gil(ceval, ceval2, tstate); 
+       We therefore avoid PyThreadState_Get() which dumps a fatal error
+       in debug mode. */
+    struct _ceval_runtime_state *ceval = &runtime->ceval;
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+    drop_gil(ceval, ceval2, tstate);
+}
+
+void
+_PyEval_ReleaseLock(PyThreadState *tstate)
+{
+    struct _ceval_runtime_state *ceval = &tstate->interp->runtime->ceval;
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+    drop_gil(ceval, ceval2, tstate);
 }
 
 void
-_PyEval_ReleaseLock(PyThreadState *tstate) 
-{ 
-    struct _ceval_runtime_state *ceval = &tstate->interp->runtime->ceval; 
-    struct _ceval_state *ceval2 = &tstate->interp->ceval; 
-    drop_gil(ceval, ceval2, tstate); 
-} 
- 
-void 
 PyEval_AcquireThread(PyThreadState *tstate)
 {
-    _Py_EnsureTstateNotNULL(tstate); 
- 
-    take_gil(tstate); 
- 
-    struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate; 
-    if (_PyThreadState_Swap(gilstate, tstate) != NULL) { 
-        Py_FatalError("non-NULL old thread state"); 
-    } 
+    _Py_EnsureTstateNotNULL(tstate);
+
+    take_gil(tstate);
+
+    struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;
+    if (_PyThreadState_Swap(gilstate, tstate) != NULL) {
+        Py_FatalError("non-NULL old thread state");
+    }
 }
 
 void
 PyEval_ReleaseThread(PyThreadState *tstate)
 {
-    assert(is_tstate_valid(tstate)); 
- 
-    _PyRuntimeState *runtime = tstate->interp->runtime; 
-    PyThreadState *new_tstate = _PyThreadState_Swap(&runtime->gilstate, NULL); 
-    if (new_tstate != tstate) { 
-        Py_FatalError("wrong thread state"); 
-    } 
-    struct _ceval_runtime_state *ceval = &runtime->ceval; 
-    struct _ceval_state *ceval2 = &tstate->interp->ceval; 
-    drop_gil(ceval, ceval2, tstate); 
+    assert(is_tstate_valid(tstate));
+
+    _PyRuntimeState *runtime = tstate->interp->runtime;
+    PyThreadState *new_tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);
+    if (new_tstate != tstate) {
+        Py_FatalError("wrong thread state");
+    }
+    struct _ceval_runtime_state *ceval = &runtime->ceval;
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+    drop_gil(ceval, ceval2, tstate);
 }
 
-#ifdef HAVE_FORK 
+#ifdef HAVE_FORK
 /* This function is called from PyOS_AfterFork_Child to destroy all threads
  * which are not running in the child process, and clear internal locks
  * which might be held by those threads.
  */
 
 void
-_PyEval_ReInitThreads(_PyRuntimeState *runtime) 
+_PyEval_ReInitThreads(_PyRuntimeState *runtime)
 {
-    PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime); 
-    _Py_EnsureTstateNotNULL(tstate); 
- 
-    struct _gil_runtime_state *gil = &runtime->ceval.gil; 
-    if (!gil_created(gil)) { 
+    PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
+    _Py_EnsureTstateNotNULL(tstate);
+
+    struct _gil_runtime_state *gil = &runtime->ceval.gil;
+    if (!gil_created(gil)) {
         return;
-    } 
-    recreate_gil(gil); 
-
-    take_gil(tstate); 
- 
-    struct _pending_calls *pending = &tstate->interp->ceval.pending; 
-    if (_PyThread_at_fork_reinit(&pending->lock) < 0) { 
-        Py_FatalError("Can't initialize threads for pending calls"); 
-    } 
- 
+    }
+    recreate_gil(gil);
+
+    take_gil(tstate);
+
+    struct _pending_calls *pending = &tstate->interp->ceval.pending;
+    if (_PyThread_at_fork_reinit(&pending->lock) < 0) {
+        Py_FatalError("Can't initialize threads for pending calls");
+    }
+
     /* Destroy all threads except the current one */
-    _PyThreadState_DeleteExcept(runtime, tstate); 
+    _PyThreadState_DeleteExcept(runtime, tstate);
 }
-#endif 
+#endif
 
 /* This function is used to signal that async exceptions are waiting to be
-   raised. */ 
+   raised. */
 
 void
-_PyEval_SignalAsyncExc(PyThreadState *tstate) 
+_PyEval_SignalAsyncExc(PyThreadState *tstate)
 {
-    assert(is_tstate_valid(tstate)); 
-    SIGNAL_ASYNC_EXC(tstate->interp); 
+    assert(is_tstate_valid(tstate));
+    SIGNAL_ASYNC_EXC(tstate->interp);
 }
 
 PyThreadState *
 PyEval_SaveThread(void)
 {
-    _PyRuntimeState *runtime = &_PyRuntime; 
-    PyThreadState *tstate = _PyThreadState_Swap(&runtime->gilstate, NULL); 
-    _Py_EnsureTstateNotNULL(tstate); 
- 
-    struct _ceval_runtime_state *ceval = &runtime->ceval; 
-    struct _ceval_state *ceval2 = &tstate->interp->ceval; 
-    assert(gil_created(&ceval->gil)); 
-    drop_gil(ceval, ceval2, tstate); 
+    _PyRuntimeState *runtime = &_PyRuntime;
+    PyThreadState *tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);
+    _Py_EnsureTstateNotNULL(tstate);
+
+    struct _ceval_runtime_state *ceval = &runtime->ceval;
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+    assert(gil_created(&ceval->gil));
+    drop_gil(ceval, ceval2, tstate);
     return tstate;
 }
 
 void
 PyEval_RestoreThread(PyThreadState *tstate)
 {
-    _Py_EnsureTstateNotNULL(tstate); 
- 
-    take_gil(tstate); 
+    _Py_EnsureTstateNotNULL(tstate);
+
+    take_gil(tstate);
 
-    struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate; 
-    _PyThreadState_Swap(gilstate, tstate); 
+    struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;
+    _PyThreadState_Swap(gilstate, tstate);
 }
 
 
@@ -494,225 +494,225 @@ PyEval_RestoreThread(PyThreadState *tstate)
 */
 
 void
-_PyEval_SignalReceived(PyInterpreterState *interp) 
+_PyEval_SignalReceived(PyInterpreterState *interp)
 {
-#ifdef MS_WINDOWS 
-    // bpo-42296: On Windows, _PyEval_SignalReceived() is called from a signal 
-    // handler which can run in a thread different than the Python thread, in 
-    // which case _Py_ThreadCanHandleSignals() is wrong. Ignore 
-    // _Py_ThreadCanHandleSignals() and always set eval_breaker to 1. 
-    // 
-    // The next eval_frame_handle_pending() call will call 
-    // _Py_ThreadCanHandleSignals() to recompute eval_breaker. 
-    int force = 1; 
-#else 
-    int force = 0; 
-#endif 
+#ifdef MS_WINDOWS
+    // bpo-42296: On Windows, _PyEval_SignalReceived() is called from a signal
+    // handler which can run in a thread different than the Python thread, in
+    // which case _Py_ThreadCanHandleSignals() is wrong. Ignore
+    // _Py_ThreadCanHandleSignals() and always set eval_breaker to 1.
+    //
+    // The next eval_frame_handle_pending() call will call
+    // _Py_ThreadCanHandleSignals() to recompute eval_breaker.
+    int force = 1;
+#else
+    int force = 0;
+#endif
     /* bpo-30703: Function called when the C signal handler of Python gets a
-       signal. We cannot queue a callback using _PyEval_AddPendingCall() since 
+       signal. We cannot queue a callback using _PyEval_AddPendingCall() since
        that function is not async-signal-safe. */
-    SIGNAL_PENDING_SIGNALS(interp, force); 
+    SIGNAL_PENDING_SIGNALS(interp, force);
+}
+
+/* Push one item onto the queue while holding the lock. */
+static int
+_push_pending_call(struct _pending_calls *pending,
+                   int (*func)(void *), void *arg)
+{
+    int i = pending->last;
+    int j = (i + 1) % NPENDINGCALLS;
+    if (j == pending->first) {
+        return -1; /* Queue full */
+    }
+    pending->calls[i].func = func;
+    pending->calls[i].arg = arg;
+    pending->last = j;
+    return 0;
+}
+
+/* Pop one item off the queue while holding the lock. */
+static void
+_pop_pending_call(struct _pending_calls *pending,
+                  int (**func)(void *), void **arg)
+{
+    int i = pending->first;
+    if (i == pending->last) {
+        return; /* Queue empty */
+    }
+
+    *func = pending->calls[i].func;
+    *arg = pending->calls[i].arg;
+    pending->first = (i + 1) % NPENDINGCALLS;
 }
 
-/* Push one item onto the queue while holding the lock. */ 
-static int 
-_push_pending_call(struct _pending_calls *pending, 
-                   int (*func)(void *), void *arg) 
-{ 
-    int i = pending->last; 
-    int j = (i + 1) % NPENDINGCALLS; 
-    if (j == pending->first) { 
-        return -1; /* Queue full */ 
-    } 
-    pending->calls[i].func = func; 
-    pending->calls[i].arg = arg; 
-    pending->last = j; 
-    return 0; 
-} 
- 
-/* Pop one item off the queue while holding the lock. */ 
-static void 
-_pop_pending_call(struct _pending_calls *pending, 
-                  int (**func)(void *), void **arg) 
-{ 
-    int i = pending->first; 
-    if (i == pending->last) { 
-        return; /* Queue empty */ 
-    } 
- 
-    *func = pending->calls[i].func; 
-    *arg = pending->calls[i].arg; 
-    pending->first = (i + 1) % NPENDINGCALLS; 
-} 
- 
 /* This implementation is thread-safe.  It allows
    scheduling to be made from any thread, and even from an executing
    callback.
  */
 
 int
-_PyEval_AddPendingCall(PyInterpreterState *interp, 
-                       int (*func)(void *), void *arg) 
+_PyEval_AddPendingCall(PyInterpreterState *interp,
+                       int (*func)(void *), void *arg)
 {
-    struct _pending_calls *pending = &interp->ceval.pending; 
+    struct _pending_calls *pending = &interp->ceval.pending;
 
-    /* Ensure that _PyEval_InitPendingCalls() was called 
-       and that _PyEval_FiniPendingCalls() is not called yet. */ 
-    assert(pending->lock != NULL); 
- 
-    PyThread_acquire_lock(pending->lock, WAIT_LOCK); 
-    int result = _push_pending_call(pending, func, arg); 
-    PyThread_release_lock(pending->lock); 
+    /* Ensure that _PyEval_InitPendingCalls() was called
+       and that _PyEval_FiniPendingCalls() is not called yet. */
+    assert(pending->lock != NULL);
+
+    PyThread_acquire_lock(pending->lock, WAIT_LOCK);
+    int result = _push_pending_call(pending, func, arg);
+    PyThread_release_lock(pending->lock);
 
     /* signal main loop */
-    SIGNAL_PENDING_CALLS(interp); 
+    SIGNAL_PENDING_CALLS(interp);
     return result;
 }
 
 int
-Py_AddPendingCall(int (*func)(void *), void *arg) 
+Py_AddPendingCall(int (*func)(void *), void *arg)
+{
+    /* Best-effort to support subinterpreters and calls with the GIL released.
+
+       First attempt _PyThreadState_GET() since it supports subinterpreters.
+
+       If the GIL is released, _PyThreadState_GET() returns NULL . In this
+       case, use PyGILState_GetThisThreadState() which works even if the GIL
+       is released.
+
+       Sadly, PyGILState_GetThisThreadState() doesn't support subinterpreters:
+       see bpo-10915 and bpo-15751.
+
+       Py_AddPendingCall() doesn't require the caller to hold the GIL. */
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (tstate == NULL) {
+        tstate = PyGILState_GetThisThreadState();
+    }
+
+    PyInterpreterState *interp;
+    if (tstate != NULL) {
+        interp = tstate->interp;
+    }
+    else {
+        /* Last resort: use the main interpreter */
+        interp = _PyRuntime.interpreters.main;
+    }
+    return _PyEval_AddPendingCall(interp, func, arg);
+}
+
+static int
+handle_signals(PyThreadState *tstate)
 {
-    /* Best-effort to support subinterpreters and calls with the GIL released. 
- 
-       First attempt _PyThreadState_GET() since it supports subinterpreters. 
- 
-       If the GIL is released, _PyThreadState_GET() returns NULL . In this 
-       case, use PyGILState_GetThisThreadState() which works even if the GIL 
-       is released. 
- 
-       Sadly, PyGILState_GetThisThreadState() doesn't support subinterpreters: 
-       see bpo-10915 and bpo-15751. 
- 
-       Py_AddPendingCall() doesn't require the caller to hold the GIL. */ 
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    if (tstate == NULL) { 
-        tstate = PyGILState_GetThisThreadState(); 
-    } 
- 
-    PyInterpreterState *interp; 
-    if (tstate != NULL) { 
-        interp = tstate->interp; 
-    } 
-    else { 
-        /* Last resort: use the main interpreter */ 
-        interp = _PyRuntime.interpreters.main; 
-    } 
-    return _PyEval_AddPendingCall(interp, func, arg); 
-} 
-
-static int 
-handle_signals(PyThreadState *tstate) 
-{ 
-    assert(is_tstate_valid(tstate)); 
-    if (!_Py_ThreadCanHandleSignals(tstate->interp)) { 
-        return 0; 
-    } 
-
-    UNSIGNAL_PENDING_SIGNALS(tstate->interp); 
-    if (_PyErr_CheckSignalsTstate(tstate) < 0) { 
-        /* On failure, re-schedule a call to handle_signals(). */ 
-        SIGNAL_PENDING_SIGNALS(tstate->interp, 0); 
-        return -1; 
-    }
-    return 0; 
-} 
-
-static int 
-make_pending_calls(PyThreadState *tstate) 
-{ 
-    assert(is_tstate_valid(tstate)); 
- 
-    /* only execute pending calls on main thread */ 
-    if (!_Py_ThreadCanHandlePendingCalls()) { 
+    assert(is_tstate_valid(tstate));
+    if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
         return 0;
     }
- 
+
+    UNSIGNAL_PENDING_SIGNALS(tstate->interp);
+    if (_PyErr_CheckSignalsTstate(tstate) < 0) {
+        /* On failure, re-schedule a call to handle_signals(). */
+        SIGNAL_PENDING_SIGNALS(tstate->interp, 0);
+        return -1;
+    }
+    return 0;
+}
+
+static int
+make_pending_calls(PyThreadState *tstate)
+{
+    assert(is_tstate_valid(tstate));
+
+    /* only execute pending calls on main thread */
+    if (!_Py_ThreadCanHandlePendingCalls()) {
+        return 0;
+    }
+
     /* don't perform recursive pending calls */
-    static int busy = 0; 
-    if (busy) { 
+    static int busy = 0;
+    if (busy) {
         return 0;
-    } 
+    }
     busy = 1;
- 
+
     /* unsignal before starting to call callbacks, so that any callback
        added in-between re-signals */
-    UNSIGNAL_PENDING_CALLS(tstate->interp); 
-    int res = 0; 
+    UNSIGNAL_PENDING_CALLS(tstate->interp);
+    int res = 0;
 
     /* perform a bounded number of calls, in case of recursion */
-    struct _pending_calls *pending = &tstate->interp->ceval.pending; 
-    for (int i=0; i<NPENDINGCALLS; i++) { 
-        int (*func)(void *) = NULL; 
+    struct _pending_calls *pending = &tstate->interp->ceval.pending;
+    for (int i=0; i<NPENDINGCALLS; i++) {
+        int (*func)(void *) = NULL;
         void *arg = NULL;
 
         /* pop one item off the queue while holding the lock */
-        PyThread_acquire_lock(pending->lock, WAIT_LOCK); 
-        _pop_pending_call(pending, &func, &arg); 
-        PyThread_release_lock(pending->lock); 
- 
+        PyThread_acquire_lock(pending->lock, WAIT_LOCK);
+        _pop_pending_call(pending, &func, &arg);
+        PyThread_release_lock(pending->lock);
+
         /* having released the lock, perform the callback */
-        if (func == NULL) { 
+        if (func == NULL) {
             break;
-        } 
-        res = func(arg); 
-        if (res) { 
+        }
+        res = func(arg);
+        if (res) {
             goto error;
         }
     }
 
     busy = 0;
-    return res; 
+    return res;
 
 error:
     busy = 0;
-    SIGNAL_PENDING_CALLS(tstate->interp); 
-    return res; 
+    SIGNAL_PENDING_CALLS(tstate->interp);
+    return res;
+}
+
+void
+_Py_FinishPendingCalls(PyThreadState *tstate)
+{
+    assert(PyGILState_Check());
+
+    struct _pending_calls *pending = &tstate->interp->ceval.pending;
+
+    if (!_Py_atomic_load_relaxed(&(pending->calls_to_do))) {
+        return;
+    }
+
+    if (make_pending_calls(tstate) < 0) {
+        PyObject *exc, *val, *tb;
+        _PyErr_Fetch(tstate, &exc, &val, &tb);
+        PyErr_BadInternalCall();
+        _PyErr_ChainExceptions(exc, val, tb);
+        _PyErr_Print(tstate);
+    }
+}
+
+/* Py_MakePendingCalls() is a simple wrapper for the sake
+   of backward-compatibility. */
+int
+Py_MakePendingCalls(void)
+{
+    assert(PyGILState_Check());
+
+    PyThreadState *tstate = _PyThreadState_GET();
+
+    /* Python signal handler doesn't really queue a callback: it only signals
+       that a signal was received, see _PyEval_SignalReceived(). */
+    int res = handle_signals(tstate);
+    if (res != 0) {
+        return res;
+    }
+
+    res = make_pending_calls(tstate);
+    if (res != 0) {
+        return res;
+    }
+
+    return 0;
 }
 
-void 
-_Py_FinishPendingCalls(PyThreadState *tstate) 
-{ 
-    assert(PyGILState_Check()); 
- 
-    struct _pending_calls *pending = &tstate->interp->ceval.pending; 
- 
-    if (!_Py_atomic_load_relaxed(&(pending->calls_to_do))) { 
-        return; 
-    } 
- 
-    if (make_pending_calls(tstate) < 0) { 
-        PyObject *exc, *val, *tb; 
-        _PyErr_Fetch(tstate, &exc, &val, &tb); 
-        PyErr_BadInternalCall(); 
-        _PyErr_ChainExceptions(exc, val, tb); 
-        _PyErr_Print(tstate); 
-    } 
-} 
- 
-/* Py_MakePendingCalls() is a simple wrapper for the sake 
-   of backward-compatibility. */ 
-int 
-Py_MakePendingCalls(void) 
-{ 
-    assert(PyGILState_Check()); 
- 
-    PyThreadState *tstate = _PyThreadState_GET(); 
- 
-    /* Python signal handler doesn't really queue a callback: it only signals 
-       that a signal was received, see _PyEval_SignalReceived(). */ 
-    int res = handle_signals(tstate); 
-    if (res != 0) { 
-        return res; 
-    } 
- 
-    res = make_pending_calls(tstate); 
-    if (res != 0) { 
-        return res; 
-    } 
- 
-    return 0; 
-} 
- 
 /* The interpreter's recursion limit */
 
 #ifndef Py_DEFAULT_RECURSION_LIMIT
@@ -722,104 +722,104 @@ Py_MakePendingCalls(void)
 int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
 
 void
-_PyEval_InitRuntimeState(struct _ceval_runtime_state *ceval) 
+_PyEval_InitRuntimeState(struct _ceval_runtime_state *ceval)
 {
     _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
-    _gil_initialize(&ceval->gil); 
+    _gil_initialize(&ceval->gil);
+}
+
+int
+_PyEval_InitState(struct _ceval_state *ceval)
+{
+    ceval->recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
+
+    struct _pending_calls *pending = &ceval->pending;
+    assert(pending->lock == NULL);
+
+    pending->lock = PyThread_allocate_lock();
+    if (pending->lock == NULL) {
+        return -1;
+    }
+
+    return 0;
+}
+
+void
+_PyEval_FiniState(struct _ceval_state *ceval)
+{
+    struct _pending_calls *pending = &ceval->pending;
+    if (pending->lock != NULL) {
+        PyThread_free_lock(pending->lock);
+        pending->lock = NULL;
+    }
 }
 
 int
-_PyEval_InitState(struct _ceval_state *ceval) 
-{ 
-    ceval->recursion_limit = Py_DEFAULT_RECURSION_LIMIT; 
- 
-    struct _pending_calls *pending = &ceval->pending; 
-    assert(pending->lock == NULL); 
- 
-    pending->lock = PyThread_allocate_lock(); 
-    if (pending->lock == NULL) { 
-        return -1; 
-    } 
- 
-    return 0; 
-} 
- 
-void 
-_PyEval_FiniState(struct _ceval_state *ceval) 
-{ 
-    struct _pending_calls *pending = &ceval->pending; 
-    if (pending->lock != NULL) { 
-        PyThread_free_lock(pending->lock); 
-        pending->lock = NULL; 
-    } 
-} 
- 
-int 
 Py_GetRecursionLimit(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return tstate->interp->ceval.recursion_limit; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    return tstate->interp->ceval.recursion_limit;
 }
 
 void
 Py_SetRecursionLimit(int new_limit)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    tstate->interp->ceval.recursion_limit = new_limit; 
-    if (_Py_IsMainInterpreter(tstate)) { 
-        _Py_CheckRecursionLimit = new_limit; 
-    } 
+    PyThreadState *tstate = _PyThreadState_GET();
+    tstate->interp->ceval.recursion_limit = new_limit;
+    if (_Py_IsMainInterpreter(tstate)) {
+        _Py_CheckRecursionLimit = new_limit;
+    }
 }
 
-/* The function _Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall() 
+/* The function _Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
    if the recursion_depth reaches _Py_CheckRecursionLimit.
    If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
    to guarantee that _Py_CheckRecursiveCall() is regularly called.
    Without USE_STACKCHECK, there is no need for this. */
 int
-_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where) 
+_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
 {
-    int recursion_limit = tstate->interp->ceval.recursion_limit; 
+    int recursion_limit = tstate->interp->ceval.recursion_limit;
 
 #ifdef USE_STACKCHECK
     tstate->stackcheck_counter = 0;
     if (PyOS_CheckStack()) {
         --tstate->recursion_depth;
-        _PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow"); 
+        _PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");
         return -1;
     }
-    if (_Py_IsMainInterpreter(tstate)) { 
-        /* Needed for ABI backwards-compatibility (see bpo-31857) */ 
-        _Py_CheckRecursionLimit = recursion_limit; 
-    } 
+    if (_Py_IsMainInterpreter(tstate)) {
+        /* Needed for ABI backwards-compatibility (see bpo-31857) */
+        _Py_CheckRecursionLimit = recursion_limit;
+    }
 #endif
-    if (tstate->recursion_critical) 
-        /* Somebody asked that we don't check for recursion. */ 
-        return 0; 
-    if (tstate->overflowed) { 
-        if (tstate->recursion_depth > recursion_limit + 50 || tstate->overflowed > 50) { 
+    if (tstate->recursion_critical)
+        /* Somebody asked that we don't check for recursion. */
+        return 0;
+    if (tstate->overflowed) {
+        if (tstate->recursion_depth > recursion_limit + 50 || tstate->overflowed > 50) {
             /* Overflowing while handling an overflow. Give up. */
             Py_FatalError("Cannot recover from stack overflow.");
         }
     }
-    else { 
-        if (tstate->recursion_depth > recursion_limit) { 
-            tstate->overflowed++; 
-            _PyErr_Format(tstate, PyExc_RecursionError, 
-                        "maximum recursion depth exceeded%s", 
-                        where); 
-            tstate->overflowed--; 
-            --tstate->recursion_depth; 
-            return -1; 
-        } 
+    else {
+        if (tstate->recursion_depth > recursion_limit) {
+            tstate->overflowed++;
+            _PyErr_Format(tstate, PyExc_RecursionError,
+                        "maximum recursion depth exceeded%s",
+                        where);
+            tstate->overflowed--;
+            --tstate->recursion_depth;
+            return -1;
+        }
     }
     return 0;
 }
 
-static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause); 
-static int unpack_iterable(PyThreadState *, PyObject *, int, int, PyObject **); 
+static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause);
+static int unpack_iterable(PyThreadState *, PyObject *, int, int, PyObject **);
 
-#define _Py_TracingPossible(ceval) ((ceval)->tracing_possible) 
+#define _Py_TracingPossible(ceval) ((ceval)->tracing_possible)
 
 
 PyObject *
@@ -837,90 +837,90 @@ PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
 /* Interpreter main loop */
 
 PyObject *
-PyEval_EvalFrame(PyFrameObject *f) 
-{ 
-    /* Function kept for backward compatibility */ 
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return _PyEval_EvalFrame(tstate, f, 0); 
+PyEval_EvalFrame(PyFrameObject *f)
+{
+    /* Function kept for backward compatibility */
+    PyThreadState *tstate = _PyThreadState_GET();
+    return _PyEval_EvalFrame(tstate, f, 0);
 }
 
 PyObject *
 PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return _PyEval_EvalFrame(tstate, f, throwflag); 
+    PyThreadState *tstate = _PyThreadState_GET();
+    return _PyEval_EvalFrame(tstate, f, throwflag);
+}
+
+
+/* Handle signals, pending calls, GIL drop request
+   and asynchronous exception */
+static int
+eval_frame_handle_pending(PyThreadState *tstate)
+{
+    _PyRuntimeState * const runtime = &_PyRuntime;
+    struct _ceval_runtime_state *ceval = &runtime->ceval;
+
+    /* Pending signals */
+    if (_Py_atomic_load_relaxed(&ceval->signals_pending)) {
+        if (handle_signals(tstate) != 0) {
+            return -1;
+        }
+    }
+
+    /* Pending calls */
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+    if (_Py_atomic_load_relaxed(&ceval2->pending.calls_to_do)) {
+        if (make_pending_calls(tstate) != 0) {
+            return -1;
+        }
+    }
+
+    /* GIL drop request */
+    if (_Py_atomic_load_relaxed(&ceval2->gil_drop_request)) {
+        /* Give another thread a chance */
+        if (_PyThreadState_Swap(&runtime->gilstate, NULL) != tstate) {
+            Py_FatalError("tstate mix-up");
+        }
+        drop_gil(ceval, ceval2, tstate);
+
+        /* Other threads may run now */
+
+        take_gil(tstate);
+
+        if (_PyThreadState_Swap(&runtime->gilstate, tstate) != NULL) {
+            Py_FatalError("orphan tstate");
+        }
+    }
+
+    /* Check for asynchronous exception. */
+    if (tstate->async_exc != NULL) {
+        PyObject *exc = tstate->async_exc;
+        tstate->async_exc = NULL;
+        UNSIGNAL_ASYNC_EXC(tstate->interp);
+        _PyErr_SetNone(tstate, exc);
+        Py_DECREF(exc);
+        return -1;
+    }
+
+#ifdef MS_WINDOWS
+    // bpo-42296: On Windows, _PyEval_SignalReceived() can be called in a
+    // different thread than the Python thread, in which case
+    // _Py_ThreadCanHandleSignals() is wrong. Recompute eval_breaker in the
+    // current Python thread with the correct _Py_ThreadCanHandleSignals()
+    // value. It prevents to interrupt the eval loop at every instruction if
+    // the current Python thread cannot handle signals (if
+    // _Py_ThreadCanHandleSignals() is false).
+    COMPUTE_EVAL_BREAKER(tstate->interp, ceval, ceval2);
+#endif
+
+    return 0;
 }
 
- 
-/* Handle signals, pending calls, GIL drop request 
-   and asynchronous exception */ 
-static int 
-eval_frame_handle_pending(PyThreadState *tstate) 
-{ 
-    _PyRuntimeState * const runtime = &_PyRuntime; 
-    struct _ceval_runtime_state *ceval = &runtime->ceval; 
- 
-    /* Pending signals */ 
-    if (_Py_atomic_load_relaxed(&ceval->signals_pending)) { 
-        if (handle_signals(tstate) != 0) { 
-            return -1; 
-        } 
-    } 
- 
-    /* Pending calls */ 
-    struct _ceval_state *ceval2 = &tstate->interp->ceval; 
-    if (_Py_atomic_load_relaxed(&ceval2->pending.calls_to_do)) { 
-        if (make_pending_calls(tstate) != 0) { 
-            return -1; 
-        } 
-    } 
- 
-    /* GIL drop request */ 
-    if (_Py_atomic_load_relaxed(&ceval2->gil_drop_request)) { 
-        /* Give another thread a chance */ 
-        if (_PyThreadState_Swap(&runtime->gilstate, NULL) != tstate) { 
-            Py_FatalError("tstate mix-up"); 
-        } 
-        drop_gil(ceval, ceval2, tstate); 
- 
-        /* Other threads may run now */ 
- 
-        take_gil(tstate); 
- 
-        if (_PyThreadState_Swap(&runtime->gilstate, tstate) != NULL) { 
-            Py_FatalError("orphan tstate"); 
-        } 
-    } 
- 
-    /* Check for asynchronous exception. */ 
-    if (tstate->async_exc != NULL) { 
-        PyObject *exc = tstate->async_exc; 
-        tstate->async_exc = NULL; 
-        UNSIGNAL_ASYNC_EXC(tstate->interp); 
-        _PyErr_SetNone(tstate, exc); 
-        Py_DECREF(exc); 
-        return -1; 
-    } 
- 
-#ifdef MS_WINDOWS 
-    // bpo-42296: On Windows, _PyEval_SignalReceived() can be called in a 
-    // different thread than the Python thread, in which case 
-    // _Py_ThreadCanHandleSignals() is wrong. Recompute eval_breaker in the 
-    // current Python thread with the correct _Py_ThreadCanHandleSignals() 
-    // value. It prevents to interrupt the eval loop at every instruction if 
-    // the current Python thread cannot handle signals (if 
-    // _Py_ThreadCanHandleSignals() is false). 
-    COMPUTE_EVAL_BREAKER(tstate->interp, ceval, ceval2); 
-#endif 
- 
-    return 0; 
-} 
- 
 PyObject* _Py_HOT_FUNCTION
-_PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag) 
+_PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 {
-    _Py_EnsureTstateNotNULL(tstate); 
- 
+    _Py_EnsureTstateNotNULL(tstate);
+
 #ifdef DXPAIRS
     int lastopcode = 0;
 #endif
@@ -930,8 +930,8 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
     int oparg;         /* Current opcode argument, if any */
     PyObject **fastlocals, **freevars;
     PyObject *retval = NULL;            /* Return value */
-    struct _ceval_state * const ceval2 = &tstate->interp->ceval; 
-    _Py_atomic_int * const eval_breaker = &ceval2->eval_breaker; 
+    struct _ceval_state * const ceval2 = &tstate->interp->ceval;
+    _Py_atomic_int * const eval_breaker = &ceval2->eval_breaker;
     PyCodeObject *co;
 
     /* when tracing we set things up so that
@@ -946,7 +946,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
     const _Py_CODEUNIT *first_instr;
     PyObject *names;
     PyObject *consts;
-    _PyOpcache *co_opcache; 
+    _PyOpcache *co_opcache;
 
 #ifdef LLTRACE
     _Py_IDENTIFIER(__ltrace__);
@@ -1013,13 +1013,13 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 #include "opcode_targets.h"
 
 #define TARGET(op) \
-    op: \ 
-    TARGET_##op 
+    op: \
+    TARGET_##op
 
 #ifdef LLTRACE
 #define FAST_DISPATCH() \
     { \
-        if (!lltrace && !_Py_TracingPossible(ceval2) && !PyDTrace_LINE_ENABLED()) { \ 
+        if (!lltrace && !_Py_TracingPossible(ceval2) && !PyDTrace_LINE_ENABLED()) { \
             f->f_lasti = INSTR_OFFSET(); \
             NEXTOPARG(); \
             goto *opcode_targets[opcode]; \
@@ -1029,7 +1029,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 #else
 #define FAST_DISPATCH() \
     { \
-        if (!_Py_TracingPossible(ceval2) && !PyDTrace_LINE_ENABLED()) { \ 
+        if (!_Py_TracingPossible(ceval2) && !PyDTrace_LINE_ENABLED()) { \
             f->f_lasti = INSTR_OFFSET(); \
             NEXTOPARG(); \
             goto *opcode_targets[opcode]; \
@@ -1038,17 +1038,17 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
     }
 #endif
 
-#define DISPATCH() \ 
-    { \ 
-        if (!_Py_atomic_load_relaxed(eval_breaker)) { \ 
-            FAST_DISPATCH(); \ 
-        } \ 
-        continue; \ 
-    } 
- 
+#define DISPATCH() \
+    { \
+        if (!_Py_atomic_load_relaxed(eval_breaker)) { \
+            FAST_DISPATCH(); \
+        } \
+        continue; \
+    }
+
 #else
-#define TARGET(op) op 
-#define FAST_DISPATCH() goto fast_next_opcode 
+#define TARGET(op) op
+#define FAST_DISPATCH() goto fast_next_opcode
 #define DISPATCH() continue
 #endif
 
@@ -1101,23 +1101,23 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 
 */
 
-#define PREDICT_ID(op)          PRED_##op 
- 
+#define PREDICT_ID(op)          PRED_##op
+
 #if defined(DYNAMIC_EXECUTION_PROFILE) || USE_COMPUTED_GOTOS
-#define PREDICT(op)             if (0) goto PREDICT_ID(op) 
+#define PREDICT(op)             if (0) goto PREDICT_ID(op)
 #else
 #define PREDICT(op) \
-    do { \ 
+    do { \
         _Py_CODEUNIT word = *next_instr; \
         opcode = _Py_OPCODE(word); \
-        if (opcode == op) { \ 
+        if (opcode == op) { \
             oparg = _Py_OPARG(word); \
             next_instr++; \
-            goto PREDICT_ID(op); \ 
+            goto PREDICT_ID(op); \
         } \
     } while(0)
 #endif
-#define PREDICTED(op)           PREDICT_ID(op): 
+#define PREDICTED(op)           PREDICT_ID(op):
 
 
 /* Stack manipulation macros */
@@ -1142,30 +1142,30 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 
 #ifdef LLTRACE
 #define PUSH(v)         { (void)(BASIC_PUSH(v), \
-                          lltrace && prtrace(tstate, TOP(), "push")); \ 
+                          lltrace && prtrace(tstate, TOP(), "push")); \
                           assert(STACK_LEVEL() <= co->co_stacksize); }
-#define POP()           ((void)(lltrace && prtrace(tstate, TOP(), "pop")), \ 
+#define POP()           ((void)(lltrace && prtrace(tstate, TOP(), "pop")), \
                          BASIC_POP())
-#define STACK_GROW(n)   do { \ 
-                          assert(n >= 0); \ 
-                          (void)(BASIC_STACKADJ(n), \ 
-                          lltrace && prtrace(tstate, TOP(), "stackadj")); \ 
-                          assert(STACK_LEVEL() <= co->co_stacksize); \ 
-                        } while (0) 
-#define STACK_SHRINK(n) do { \ 
-                            assert(n >= 0); \ 
-                            (void)(lltrace && prtrace(tstate, TOP(), "stackadj")); \ 
-                            (void)(BASIC_STACKADJ(-n)); \ 
-                            assert(STACK_LEVEL() <= co->co_stacksize); \ 
-                        } while (0) 
+#define STACK_GROW(n)   do { \
+                          assert(n >= 0); \
+                          (void)(BASIC_STACKADJ(n), \
+                          lltrace && prtrace(tstate, TOP(), "stackadj")); \
+                          assert(STACK_LEVEL() <= co->co_stacksize); \
+                        } while (0)
+#define STACK_SHRINK(n) do { \
+                            assert(n >= 0); \
+                            (void)(lltrace && prtrace(tstate, TOP(), "stackadj")); \
+                            (void)(BASIC_STACKADJ(-n)); \
+                            assert(STACK_LEVEL() <= co->co_stacksize); \
+                        } while (0)
 #define EXT_POP(STACK_POINTER) ((void)(lltrace && \
-                                prtrace(tstate, (STACK_POINTER)[-1], "ext_pop")), \ 
+                                prtrace(tstate, (STACK_POINTER)[-1], "ext_pop")), \
                                 *--(STACK_POINTER))
 #else
 #define PUSH(v)                BASIC_PUSH(v)
 #define POP()                  BASIC_POP()
-#define STACK_GROW(n)          BASIC_STACKADJ(n) 
-#define STACK_SHRINK(n)        BASIC_STACKADJ(-n) 
+#define STACK_GROW(n)          BASIC_STACKADJ(n)
+#define STACK_SHRINK(n)        BASIC_STACKADJ(-n)
 #define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
 #endif
 
@@ -1211,52 +1211,52 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
         Py_XDECREF(traceback); \
     } while(0)
 
-    /* macros for opcode cache */ 
-#define OPCACHE_CHECK() \ 
-    do { \ 
-        co_opcache = NULL; \ 
-        if (co->co_opcache != NULL) { \ 
-            unsigned char co_opt_offset = \ 
-                co->co_opcache_map[next_instr - first_instr]; \ 
-            if (co_opt_offset > 0) { \ 
-                assert(co_opt_offset <= co->co_opcache_size); \ 
-                co_opcache = &co->co_opcache[co_opt_offset - 1]; \ 
-                assert(co_opcache != NULL); \ 
-            } \ 
-        } \ 
-    } while (0) 
- 
-#if OPCACHE_STATS 
- 
-#define OPCACHE_STAT_GLOBAL_HIT() \ 
-    do { \ 
-        if (co->co_opcache != NULL) opcache_global_hits++; \ 
-    } while (0) 
- 
-#define OPCACHE_STAT_GLOBAL_MISS() \ 
-    do { \ 
-        if (co->co_opcache != NULL) opcache_global_misses++; \ 
-    } while (0) 
- 
-#define OPCACHE_STAT_GLOBAL_OPT() \ 
-    do { \ 
-        if (co->co_opcache != NULL) opcache_global_opts++; \ 
-    } while (0) 
- 
-#else /* OPCACHE_STATS */ 
- 
-#define OPCACHE_STAT_GLOBAL_HIT() 
-#define OPCACHE_STAT_GLOBAL_MISS() 
-#define OPCACHE_STAT_GLOBAL_OPT() 
- 
-#endif 
- 
+    /* macros for opcode cache */
+#define OPCACHE_CHECK() \
+    do { \
+        co_opcache = NULL; \
+        if (co->co_opcache != NULL) { \
+            unsigned char co_opt_offset = \
+                co->co_opcache_map[next_instr - first_instr]; \
+            if (co_opt_offset > 0) { \
+                assert(co_opt_offset <= co->co_opcache_size); \
+                co_opcache = &co->co_opcache[co_opt_offset - 1]; \
+                assert(co_opcache != NULL); \
+            } \
+        } \
+    } while (0)
+
+#if OPCACHE_STATS
+
+#define OPCACHE_STAT_GLOBAL_HIT() \
+    do { \
+        if (co->co_opcache != NULL) opcache_global_hits++; \
+    } while (0)
+
+#define OPCACHE_STAT_GLOBAL_MISS() \
+    do { \
+        if (co->co_opcache != NULL) opcache_global_misses++; \
+    } while (0)
+
+#define OPCACHE_STAT_GLOBAL_OPT() \
+    do { \
+        if (co->co_opcache != NULL) opcache_global_opts++; \
+    } while (0)
+
+#else /* OPCACHE_STATS */
+
+#define OPCACHE_STAT_GLOBAL_HIT()
+#define OPCACHE_STAT_GLOBAL_MISS()
+#define OPCACHE_STAT_GLOBAL_OPT()
+
+#endif
+
 /* Start of code */
 
     /* push frame */
-    if (_Py_EnterRecursiveCall(tstate, "")) { 
+    if (_Py_EnterRecursiveCall(tstate, "")) {
         return NULL;
-    } 
+    }
 
     tstate->frame = f;
 
@@ -1333,20 +1333,20 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
     f->f_stacktop = NULL;       /* remains NULL unless yield suspends frame */
     f->f_executing = 1;
 
-    if (co->co_opcache_flag < OPCACHE_MIN_RUNS) { 
-        co->co_opcache_flag++; 
-        if (co->co_opcache_flag == OPCACHE_MIN_RUNS) { 
-            if (_PyCode_InitOpcache(co) < 0) { 
-                goto exit_eval_frame; 
-            } 
-#if OPCACHE_STATS 
-            opcache_code_objects_extra_mem += 
-                PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT) + 
-                sizeof(_PyOpcache) * co->co_opcache_size; 
-            opcache_code_objects++; 
-#endif 
-        } 
-    } 
+    if (co->co_opcache_flag < OPCACHE_MIN_RUNS) {
+        co->co_opcache_flag++;
+        if (co->co_opcache_flag == OPCACHE_MIN_RUNS) {
+            if (_PyCode_InitOpcache(co) < 0) {
+                goto exit_eval_frame;
+            }
+#if OPCACHE_STATS
+            opcache_code_objects_extra_mem +=
+                PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT) +
+                sizeof(_PyOpcache) * co->co_opcache_size;
+            opcache_code_objects++;
+#endif
+        }
+    }
 
 #ifdef LLTRACE
     lltrace = _PyDict_GetItemId(f->f_globals, &PyId___ltrace__) != NULL;
@@ -1356,27 +1356,27 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
         goto error;
 
 #ifdef Py_DEBUG
-    /* _PyEval_EvalFrameDefault() must not be called with an exception set, 
+    /* _PyEval_EvalFrameDefault() must not be called with an exception set,
        because it can clear it (directly or indirectly) and so the
        caller loses its exception */
-    assert(!_PyErr_Occurred(tstate)); 
+    assert(!_PyErr_Occurred(tstate));
 #endif
 
-main_loop: 
+main_loop:
     for (;;) {
         assert(stack_pointer >= f->f_valuestack); /* else underflow */
         assert(STACK_LEVEL() <= co->co_stacksize);  /* else overflow */
-        assert(!_PyErr_Occurred(tstate)); 
+        assert(!_PyErr_Occurred(tstate));
 
         /* Do periodic things.  Doing this every time through
            the loop would add too much overhead, so we do it
            only every Nth instruction.  We also do it if
-           ``pending.calls_to_do'' is set, i.e. when an asynchronous 
+           ``pending.calls_to_do'' is set, i.e. when an asynchronous
            event needs attention (e.g. a signal handler or
            async I/O handler); see Py_AddPendingCall() and
            Py_MakePendingCalls() above. */
 
-        if (_Py_atomic_load_relaxed(eval_breaker)) { 
+        if (_Py_atomic_load_relaxed(eval_breaker)) {
             opcode = _Py_OPCODE(*next_instr);
             if (opcode == SETUP_FINALLY ||
                 opcode == SETUP_WITH ||
@@ -1400,8 +1400,8 @@ main_loop:
                 */
                 goto fast_next_opcode;
             }
- 
-            if (eval_frame_handle_pending(tstate) != 0) { 
+
+            if (eval_frame_handle_pending(tstate) != 0) {
                 goto error;
             }
         }
@@ -1414,7 +1414,7 @@ main_loop:
 
         /* line-by-line tracing support */
 
-        if (_Py_TracingPossible(ceval2) && 
+        if (_Py_TracingPossible(ceval2) &&
             tstate->c_tracefunc != NULL && !tstate->tracing) {
             int err;
             /* see maybe_call_line_trace
@@ -1466,17 +1466,17 @@ main_loop:
         switch (opcode) {
 
         /* BEWARE!
-           It is essential that any operation that fails must goto error 
-           and that all operation that succeed call [FAST_]DISPATCH() ! */ 
+           It is essential that any operation that fails must goto error
+           and that all operation that succeed call [FAST_]DISPATCH() ! */
 
-        case TARGET(NOP): { 
+        case TARGET(NOP): {
             FAST_DISPATCH();
-        } 
+        }
 
-        case TARGET(LOAD_FAST): { 
+        case TARGET(LOAD_FAST): {
             PyObject *value = GETLOCAL(oparg);
             if (value == NULL) {
-                format_exc_check_arg(tstate, PyExc_UnboundLocalError, 
+                format_exc_check_arg(tstate, PyExc_UnboundLocalError,
                                      UNBOUNDLOCAL_ERROR_MSG,
                                      PyTuple_GetItem(co->co_varnames, oparg));
                 goto error;
@@ -1486,28 +1486,28 @@ main_loop:
             FAST_DISPATCH();
         }
 
-        case TARGET(LOAD_CONST): { 
-            PREDICTED(LOAD_CONST); 
+        case TARGET(LOAD_CONST): {
+            PREDICTED(LOAD_CONST);
             PyObject *value = GETITEM(consts, oparg);
             Py_INCREF(value);
             PUSH(value);
             FAST_DISPATCH();
         }
 
-        case TARGET(STORE_FAST): { 
-            PREDICTED(STORE_FAST); 
+        case TARGET(STORE_FAST): {
+            PREDICTED(STORE_FAST);
             PyObject *value = POP();
             SETLOCAL(oparg, value);
             FAST_DISPATCH();
         }
 
-        case TARGET(POP_TOP): { 
+        case TARGET(POP_TOP): {
             PyObject *value = POP();
             Py_DECREF(value);
             FAST_DISPATCH();
         }
 
-        case TARGET(ROT_TWO): { 
+        case TARGET(ROT_TWO): {
             PyObject *top = TOP();
             PyObject *second = SECOND();
             SET_TOP(second);
@@ -1515,7 +1515,7 @@ main_loop:
             FAST_DISPATCH();
         }
 
-        case TARGET(ROT_THREE): { 
+        case TARGET(ROT_THREE): {
             PyObject *top = TOP();
             PyObject *second = SECOND();
             PyObject *third = THIRD();
@@ -1525,37 +1525,37 @@ main_loop:
             FAST_DISPATCH();
         }
 
-        case TARGET(ROT_FOUR): { 
+        case TARGET(ROT_FOUR): {
+            PyObject *top = TOP();
+            PyObject *second = SECOND();
+            PyObject *third = THIRD();
+            PyObject *fourth = FOURTH();
+            SET_TOP(second);
+            SET_SECOND(third);
+            SET_THIRD(fourth);
+            SET_FOURTH(top);
+            FAST_DISPATCH();
+        }
+
+        case TARGET(DUP_TOP): {
             PyObject *top = TOP();
-            PyObject *second = SECOND(); 
-            PyObject *third = THIRD(); 
-            PyObject *fourth = FOURTH(); 
-            SET_TOP(second); 
-            SET_SECOND(third); 
-            SET_THIRD(fourth); 
-            SET_FOURTH(top); 
-            FAST_DISPATCH(); 
-        } 
- 
-        case TARGET(DUP_TOP): { 
-            PyObject *top = TOP(); 
             Py_INCREF(top);
             PUSH(top);
             FAST_DISPATCH();
         }
 
-        case TARGET(DUP_TOP_TWO): { 
+        case TARGET(DUP_TOP_TWO): {
             PyObject *top = TOP();
             PyObject *second = SECOND();
             Py_INCREF(top);
             Py_INCREF(second);
-            STACK_GROW(2); 
+            STACK_GROW(2);
             SET_TOP(top);
             SET_SECOND(second);
             FAST_DISPATCH();
         }
 
-        case TARGET(UNARY_POSITIVE): { 
+        case TARGET(UNARY_POSITIVE): {
             PyObject *value = TOP();
             PyObject *res = PyNumber_Positive(value);
             Py_DECREF(value);
@@ -1565,7 +1565,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(UNARY_NEGATIVE): { 
+        case TARGET(UNARY_NEGATIVE): {
             PyObject *value = TOP();
             PyObject *res = PyNumber_Negative(value);
             Py_DECREF(value);
@@ -1575,7 +1575,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(UNARY_NOT): { 
+        case TARGET(UNARY_NOT): {
             PyObject *value = TOP();
             int err = PyObject_IsTrue(value);
             Py_DECREF(value);
@@ -1589,11 +1589,11 @@ main_loop:
                 SET_TOP(Py_False);
                 DISPATCH();
             }
-            STACK_SHRINK(1); 
+            STACK_SHRINK(1);
             goto error;
         }
 
-        case TARGET(UNARY_INVERT): { 
+        case TARGET(UNARY_INVERT): {
             PyObject *value = TOP();
             PyObject *res = PyNumber_Invert(value);
             Py_DECREF(value);
@@ -1603,7 +1603,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_POWER): { 
+        case TARGET(BINARY_POWER): {
             PyObject *exp = POP();
             PyObject *base = TOP();
             PyObject *res = PyNumber_Power(base, exp, Py_None);
@@ -1615,7 +1615,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_MULTIPLY): { 
+        case TARGET(BINARY_MULTIPLY): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_Multiply(left, right);
@@ -1627,7 +1627,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_MATRIX_MULTIPLY): { 
+        case TARGET(BINARY_MATRIX_MULTIPLY): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_MatrixMultiply(left, right);
@@ -1639,7 +1639,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_TRUE_DIVIDE): { 
+        case TARGET(BINARY_TRUE_DIVIDE): {
             PyObject *divisor = POP();
             PyObject *dividend = TOP();
             PyObject *quotient = PyNumber_TrueDivide(dividend, divisor);
@@ -1651,7 +1651,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_FLOOR_DIVIDE): { 
+        case TARGET(BINARY_FLOOR_DIVIDE): {
             PyObject *divisor = POP();
             PyObject *dividend = TOP();
             PyObject *quotient = PyNumber_FloorDivide(dividend, divisor);
@@ -1663,7 +1663,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_MODULO): { 
+        case TARGET(BINARY_MODULO): {
             PyObject *divisor = POP();
             PyObject *dividend = TOP();
             PyObject *res;
@@ -1683,7 +1683,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_ADD): { 
+        case TARGET(BINARY_ADD): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *sum;
@@ -1695,7 +1695,7 @@ main_loop:
                speedup on microbenchmarks. */
             if (PyUnicode_CheckExact(left) &&
                      PyUnicode_CheckExact(right)) {
-                sum = unicode_concatenate(tstate, left, right, f, next_instr); 
+                sum = unicode_concatenate(tstate, left, right, f, next_instr);
                 /* unicode_concatenate consumed the ref to left */
             }
             else {
@@ -1709,7 +1709,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_SUBTRACT): { 
+        case TARGET(BINARY_SUBTRACT): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *diff = PyNumber_Subtract(left, right);
@@ -1721,7 +1721,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_SUBSCR): { 
+        case TARGET(BINARY_SUBSCR): {
             PyObject *sub = POP();
             PyObject *container = TOP();
             PyObject *res = PyObject_GetItem(container, sub);
@@ -1733,7 +1733,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_LSHIFT): { 
+        case TARGET(BINARY_LSHIFT): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_Lshift(left, right);
@@ -1745,7 +1745,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_RSHIFT): { 
+        case TARGET(BINARY_RSHIFT): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_Rshift(left, right);
@@ -1757,7 +1757,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_AND): { 
+        case TARGET(BINARY_AND): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_And(left, right);
@@ -1769,7 +1769,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_XOR): { 
+        case TARGET(BINARY_XOR): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_Xor(left, right);
@@ -1781,7 +1781,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BINARY_OR): { 
+        case TARGET(BINARY_OR): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_Or(left, right);
@@ -1793,7 +1793,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(LIST_APPEND): { 
+        case TARGET(LIST_APPEND): {
             PyObject *v = POP();
             PyObject *list = PEEK(oparg);
             int err;
@@ -1805,7 +1805,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(SET_ADD): { 
+        case TARGET(SET_ADD): {
             PyObject *v = POP();
             PyObject *set = PEEK(oparg);
             int err;
@@ -1817,7 +1817,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_POWER): { 
+        case TARGET(INPLACE_POWER): {
             PyObject *exp = POP();
             PyObject *base = TOP();
             PyObject *res = PyNumber_InPlacePower(base, exp, Py_None);
@@ -1829,7 +1829,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_MULTIPLY): { 
+        case TARGET(INPLACE_MULTIPLY): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceMultiply(left, right);
@@ -1841,7 +1841,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_MATRIX_MULTIPLY): { 
+        case TARGET(INPLACE_MATRIX_MULTIPLY): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceMatrixMultiply(left, right);
@@ -1853,7 +1853,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_TRUE_DIVIDE): { 
+        case TARGET(INPLACE_TRUE_DIVIDE): {
             PyObject *divisor = POP();
             PyObject *dividend = TOP();
             PyObject *quotient = PyNumber_InPlaceTrueDivide(dividend, divisor);
@@ -1865,7 +1865,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_FLOOR_DIVIDE): { 
+        case TARGET(INPLACE_FLOOR_DIVIDE): {
             PyObject *divisor = POP();
             PyObject *dividend = TOP();
             PyObject *quotient = PyNumber_InPlaceFloorDivide(dividend, divisor);
@@ -1877,7 +1877,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_MODULO): { 
+        case TARGET(INPLACE_MODULO): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *mod = PyNumber_InPlaceRemainder(left, right);
@@ -1889,12 +1889,12 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_ADD): { 
+        case TARGET(INPLACE_ADD): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *sum;
             if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) {
-                sum = unicode_concatenate(tstate, left, right, f, next_instr); 
+                sum = unicode_concatenate(tstate, left, right, f, next_instr);
                 /* unicode_concatenate consumed the ref to left */
             }
             else {
@@ -1908,7 +1908,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_SUBTRACT): { 
+        case TARGET(INPLACE_SUBTRACT): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *diff = PyNumber_InPlaceSubtract(left, right);
@@ -1920,7 +1920,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_LSHIFT): { 
+        case TARGET(INPLACE_LSHIFT): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceLshift(left, right);
@@ -1932,7 +1932,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_RSHIFT): { 
+        case TARGET(INPLACE_RSHIFT): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceRshift(left, right);
@@ -1944,7 +1944,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_AND): { 
+        case TARGET(INPLACE_AND): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceAnd(left, right);
@@ -1956,7 +1956,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_XOR): { 
+        case TARGET(INPLACE_XOR): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceXor(left, right);
@@ -1968,7 +1968,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(INPLACE_OR): { 
+        case TARGET(INPLACE_OR): {
             PyObject *right = POP();
             PyObject *left = TOP();
             PyObject *res = PyNumber_InPlaceOr(left, right);
@@ -1980,12 +1980,12 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(STORE_SUBSCR): { 
+        case TARGET(STORE_SUBSCR): {
             PyObject *sub = TOP();
             PyObject *container = SECOND();
             PyObject *v = THIRD();
             int err;
-            STACK_SHRINK(3); 
+            STACK_SHRINK(3);
             /* container[sub] = v */
             err = PyObject_SetItem(container, sub, v);
             Py_DECREF(v);
@@ -1996,11 +1996,11 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(DELETE_SUBSCR): { 
+        case TARGET(DELETE_SUBSCR): {
             PyObject *sub = TOP();
             PyObject *container = SECOND();
             int err;
-            STACK_SHRINK(2); 
+            STACK_SHRINK(2);
             /* del container[sub] */
             err = PyObject_DelItem(container, sub);
             Py_DECREF(container);
@@ -2010,18 +2010,18 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(PRINT_EXPR): { 
+        case TARGET(PRINT_EXPR): {
             _Py_IDENTIFIER(displayhook);
             PyObject *value = POP();
             PyObject *hook = _PySys_GetObjectId(&PyId_displayhook);
             PyObject *res;
             if (hook == NULL) {
-                _PyErr_SetString(tstate, PyExc_RuntimeError, 
-                                 "lost sys.displayhook"); 
+                _PyErr_SetString(tstate, PyExc_RuntimeError,
+                                 "lost sys.displayhook");
                 Py_DECREF(value);
                 goto error;
             }
-            res = PyObject_CallOneArg(hook, value); 
+            res = PyObject_CallOneArg(hook, value);
             Py_DECREF(value);
             if (res == NULL)
                 goto error;
@@ -2029,7 +2029,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(RAISE_VARARGS): { 
+        case TARGET(RAISE_VARARGS): {
             PyObject *cause = NULL, *exc = NULL;
             switch (oparg) {
             case 2:
@@ -2039,26 +2039,26 @@ main_loop:
                 exc = POP(); /* exc */
                 /* fall through */
             case 0:
-                if (do_raise(tstate, exc, cause)) { 
-                    goto exception_unwind; 
+                if (do_raise(tstate, exc, cause)) {
+                    goto exception_unwind;
                 }
                 break;
             default:
-                _PyErr_SetString(tstate, PyExc_SystemError, 
-                                 "bad RAISE_VARARGS oparg"); 
+                _PyErr_SetString(tstate, PyExc_SystemError,
+                                 "bad RAISE_VARARGS oparg");
                 break;
             }
             goto error;
         }
 
-        case TARGET(RETURN_VALUE): { 
+        case TARGET(RETURN_VALUE): {
             retval = POP();
-            assert(f->f_iblock == 0); 
-            assert(EMPTY()); 
-            goto exiting; 
+            assert(f->f_iblock == 0);
+            assert(EMPTY());
+            goto exiting;
         }
 
-        case TARGET(GET_AITER): { 
+        case TARGET(GET_AITER): {
             unaryfunc getter = NULL;
             PyObject *iter = NULL;
             PyObject *obj = TOP();
@@ -2078,10 +2078,10 @@ main_loop:
             }
             else {
                 SET_TOP(NULL);
-                _PyErr_Format(tstate, PyExc_TypeError, 
-                              "'async for' requires an object with " 
-                              "__aiter__ method, got %.100s", 
-                              type->tp_name); 
+                _PyErr_Format(tstate, PyExc_TypeError,
+                              "'async for' requires an object with "
+                              "__aiter__ method, got %.100s",
+                              type->tp_name);
                 Py_DECREF(obj);
                 goto error;
             }
@@ -2090,10 +2090,10 @@ main_loop:
                     Py_TYPE(iter)->tp_as_async->am_anext == NULL) {
 
                 SET_TOP(NULL);
-                _PyErr_Format(tstate, PyExc_TypeError, 
-                              "'async for' received an object from __aiter__ " 
-                              "that does not implement __anext__: %.100s", 
-                              Py_TYPE(iter)->tp_name); 
+                _PyErr_Format(tstate, PyExc_TypeError,
+                              "'async for' received an object from __aiter__ "
+                              "that does not implement __anext__: %.100s",
+                              Py_TYPE(iter)->tp_name);
                 Py_DECREF(iter);
                 goto error;
             }
@@ -2102,7 +2102,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(GET_ANEXT): { 
+        case TARGET(GET_ANEXT): {
             unaryfunc getter = NULL;
             PyObject *next_iter = NULL;
             PyObject *awaitable = NULL;
@@ -2126,10 +2126,10 @@ main_loop:
                     }
                 }
                 else {
-                    _PyErr_Format(tstate, PyExc_TypeError, 
-                                  "'async for' requires an iterator with " 
-                                  "__anext__ method, got %.100s", 
-                                  type->tp_name); 
+                    _PyErr_Format(tstate, PyExc_TypeError,
+                                  "'async for' requires an iterator with "
+                                  "__anext__ method, got %.100s",
+                                  type->tp_name);
                     goto error;
                 }
 
@@ -2153,18 +2153,18 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(GET_AWAITABLE): { 
-            PREDICTED(GET_AWAITABLE); 
+        case TARGET(GET_AWAITABLE): {
+            PREDICTED(GET_AWAITABLE);
             PyObject *iterable = TOP();
             PyObject *iter = _PyCoro_GetAwaitableIter(iterable);
 
             if (iter == NULL) {
-                int opcode_at_minus_3 = 0; 
-                if ((next_instr - first_instr) > 2) { 
-                    opcode_at_minus_3 = _Py_OPCODE(next_instr[-3]); 
-                } 
-                format_awaitable_error(tstate, Py_TYPE(iterable), 
-                                       opcode_at_minus_3, 
+                int opcode_at_minus_3 = 0;
+                if ((next_instr - first_instr) > 2) {
+                    opcode_at_minus_3 = _Py_OPCODE(next_instr[-3]);
+                }
+                format_awaitable_error(tstate, Py_TYPE(iterable),
+                                       opcode_at_minus_3,
                                        _Py_OPCODE(next_instr[-2]));
             }
 
@@ -2178,8 +2178,8 @@ main_loop:
                        being awaited on. */
                     Py_DECREF(yf);
                     Py_CLEAR(iter);
-                    _PyErr_SetString(tstate, PyExc_RuntimeError, 
-                                     "coroutine is being awaited already"); 
+                    _PyErr_SetString(tstate, PyExc_RuntimeError,
+                                     "coroutine is being awaited already");
                     /* The code below jumps to `error` if `iter` is NULL. */
                 }
             }
@@ -2194,7 +2194,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(YIELD_FROM): { 
+        case TARGET(YIELD_FROM): {
             PyObject *v = POP();
             PyObject *receiver = TOP();
             int err;
@@ -2205,13 +2205,13 @@ main_loop:
                 if (v == Py_None)
                     retval = Py_TYPE(receiver)->tp_iternext(receiver);
                 else
-                    retval = _PyObject_CallMethodIdOneArg(receiver, &PyId_send, v); 
+                    retval = _PyObject_CallMethodIdOneArg(receiver, &PyId_send, v);
             }
             Py_DECREF(v);
             if (retval == NULL) {
                 PyObject *val;
                 if (tstate->c_tracefunc != NULL
-                        && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) 
+                        && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
                     call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f);
                 err = _PyGen_FetchStopIterationValue(&val);
                 if (err < 0)
@@ -2225,10 +2225,10 @@ main_loop:
             /* and repeat... */
             assert(f->f_lasti >= (int)sizeof(_Py_CODEUNIT));
             f->f_lasti -= sizeof(_Py_CODEUNIT);
-            goto exiting; 
+            goto exiting;
         }
 
-        case TARGET(YIELD_VALUE): { 
+        case TARGET(YIELD_VALUE): {
             retval = POP();
 
             if (co->co_flags & CO_ASYNC_GENERATOR) {
@@ -2242,86 +2242,86 @@ main_loop:
             }
 
             f->f_stacktop = stack_pointer;
-            goto exiting; 
+            goto exiting;
         }
 
-        case TARGET(POP_EXCEPT): { 
-            PyObject *type, *value, *traceback; 
-            _PyErr_StackItem *exc_info; 
+        case TARGET(POP_EXCEPT): {
+            PyObject *type, *value, *traceback;
+            _PyErr_StackItem *exc_info;
             PyTryBlock *b = PyFrame_BlockPop(f);
             if (b->b_type != EXCEPT_HANDLER) {
-                _PyErr_SetString(tstate, PyExc_SystemError, 
-                                 "popped block is not an except handler"); 
+                _PyErr_SetString(tstate, PyExc_SystemError,
+                                 "popped block is not an except handler");
                 goto error;
             }
-            assert(STACK_LEVEL() >= (b)->b_level + 3 && 
-                   STACK_LEVEL() <= (b)->b_level + 4); 
-            exc_info = tstate->exc_info; 
-            type = exc_info->exc_type; 
-            value = exc_info->exc_value; 
-            traceback = exc_info->exc_traceback; 
-            exc_info->exc_type = POP(); 
-            exc_info->exc_value = POP(); 
-            exc_info->exc_traceback = POP(); 
-            Py_XDECREF(type); 
-            Py_XDECREF(value); 
-            Py_XDECREF(traceback); 
+            assert(STACK_LEVEL() >= (b)->b_level + 3 &&
+                   STACK_LEVEL() <= (b)->b_level + 4);
+            exc_info = tstate->exc_info;
+            type = exc_info->exc_type;
+            value = exc_info->exc_value;
+            traceback = exc_info->exc_traceback;
+            exc_info->exc_type = POP();
+            exc_info->exc_value = POP();
+            exc_info->exc_traceback = POP();
+            Py_XDECREF(type);
+            Py_XDECREF(value);
+            Py_XDECREF(traceback);
             DISPATCH();
         }
 
-        case TARGET(POP_BLOCK): { 
-            PREDICTED(POP_BLOCK); 
-            PyFrame_BlockPop(f); 
+        case TARGET(POP_BLOCK): {
+            PREDICTED(POP_BLOCK);
+            PyFrame_BlockPop(f);
             DISPATCH();
         }
 
-        case TARGET(RERAISE): { 
-            PyObject *exc = POP(); 
-            PyObject *val = POP(); 
-            PyObject *tb = POP(); 
-            assert(PyExceptionClass_Check(exc)); 
-            _PyErr_Restore(tstate, exc, val, tb); 
-            goto exception_unwind; 
-        } 
- 
-        case TARGET(END_ASYNC_FOR): { 
-            PyObject *exc = POP(); 
-            assert(PyExceptionClass_Check(exc)); 
-            if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) { 
-                PyTryBlock *b = PyFrame_BlockPop(f); 
-                assert(b->b_type == EXCEPT_HANDLER); 
-                Py_DECREF(exc); 
-                UNWIND_EXCEPT_HANDLER(b); 
-                Py_DECREF(POP()); 
-                JUMPBY(oparg); 
-                FAST_DISPATCH(); 
-            } 
-            else { 
-                PyObject *val = POP(); 
-                PyObject *tb = POP(); 
-                _PyErr_Restore(tstate, exc, val, tb); 
-                goto exception_unwind; 
-            } 
-        } 
- 
-        case TARGET(LOAD_ASSERTION_ERROR): { 
-            PyObject *value = PyExc_AssertionError; 
-            Py_INCREF(value); 
-            PUSH(value); 
-            FAST_DISPATCH(); 
-        } 
- 
-        case TARGET(LOAD_BUILD_CLASS): { 
+        case TARGET(RERAISE): {
+            PyObject *exc = POP();
+            PyObject *val = POP();
+            PyObject *tb = POP();
+            assert(PyExceptionClass_Check(exc));
+            _PyErr_Restore(tstate, exc, val, tb);
+            goto exception_unwind;
+        }
+
+        case TARGET(END_ASYNC_FOR): {
+            PyObject *exc = POP();
+            assert(PyExceptionClass_Check(exc));
+            if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
+                PyTryBlock *b = PyFrame_BlockPop(f);
+                assert(b->b_type == EXCEPT_HANDLER);
+                Py_DECREF(exc);
+                UNWIND_EXCEPT_HANDLER(b);
+                Py_DECREF(POP());
+                JUMPBY(oparg);
+                FAST_DISPATCH();
+            }
+            else {
+                PyObject *val = POP();
+                PyObject *tb = POP();
+                _PyErr_Restore(tstate, exc, val, tb);
+                goto exception_unwind;
+            }
+        }
+
+        case TARGET(LOAD_ASSERTION_ERROR): {
+            PyObject *value = PyExc_AssertionError;
+            Py_INCREF(value);
+            PUSH(value);
+            FAST_DISPATCH();
+        }
+
+        case TARGET(LOAD_BUILD_CLASS): {
             _Py_IDENTIFIER(__build_class__);
 
             PyObject *bc;
             if (PyDict_CheckExact(f->f_builtins)) {
-                bc = _PyDict_GetItemIdWithError(f->f_builtins, &PyId___build_class__); 
+                bc = _PyDict_GetItemIdWithError(f->f_builtins, &PyId___build_class__);
                 if (bc == NULL) {
-                    if (!_PyErr_Occurred(tstate)) { 
-                        _PyErr_SetString(tstate, PyExc_NameError, 
-                                         "__build_class__ not found"); 
-                    } 
+                    if (!_PyErr_Occurred(tstate)) {
+                        _PyErr_SetString(tstate, PyExc_NameError,
+                                         "__build_class__ not found");
+                    }
                     goto error;
                 }
                 Py_INCREF(bc);
@@ -2332,9 +2332,9 @@ main_loop:
                     goto error;
                 bc = PyObject_GetItem(f->f_builtins, build_class_str);
                 if (bc == NULL) {
-                    if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) 
-                        _PyErr_SetString(tstate, PyExc_NameError, 
-                                         "__build_class__ not found"); 
+                    if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
+                        _PyErr_SetString(tstate, PyExc_NameError,
+                                         "__build_class__ not found");
                     goto error;
                 }
             }
@@ -2342,14 +2342,14 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(STORE_NAME): { 
+        case TARGET(STORE_NAME): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *v = POP();
             PyObject *ns = f->f_locals;
             int err;
             if (ns == NULL) {
-                _PyErr_Format(tstate, PyExc_SystemError, 
-                              "no locals found when storing %R", name); 
+                _PyErr_Format(tstate, PyExc_SystemError,
+                              "no locals found when storing %R", name);
                 Py_DECREF(v);
                 goto error;
             }
@@ -2363,18 +2363,18 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(DELETE_NAME): { 
+        case TARGET(DELETE_NAME): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *ns = f->f_locals;
             int err;
             if (ns == NULL) {
-                _PyErr_Format(tstate, PyExc_SystemError, 
-                              "no locals when deleting %R", name); 
+                _PyErr_Format(tstate, PyExc_SystemError,
+                              "no locals when deleting %R", name);
                 goto error;
             }
             err = PyObject_DelItem(ns, name);
             if (err != 0) {
-                format_exc_check_arg(tstate, PyExc_NameError, 
+                format_exc_check_arg(tstate, PyExc_NameError,
                                      NAME_ERROR_MSG,
                                      name);
                 goto error;
@@ -2382,8 +2382,8 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(UNPACK_SEQUENCE): { 
-            PREDICTED(UNPACK_SEQUENCE); 
+        case TARGET(UNPACK_SEQUENCE): {
+            PREDICTED(UNPACK_SEQUENCE);
             PyObject *seq = POP(), *item, **items;
             if (PyTuple_CheckExact(seq) &&
                 PyTuple_GET_SIZE(seq) == oparg) {
@@ -2401,9 +2401,9 @@ main_loop:
                     Py_INCREF(item);
                     PUSH(item);
                 }
-            } else if (unpack_iterable(tstate, seq, oparg, -1, 
+            } else if (unpack_iterable(tstate, seq, oparg, -1,
                                        stack_pointer + oparg)) {
-                STACK_GROW(oparg); 
+                STACK_GROW(oparg);
             } else {
                 /* unpack_iterable() raised an exception */
                 Py_DECREF(seq);
@@ -2413,11 +2413,11 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(UNPACK_EX): { 
+        case TARGET(UNPACK_EX): {
             int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
             PyObject *seq = POP();
 
-            if (unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8, 
+            if (unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8,
                                 stack_pointer + totalargs)) {
                 stack_pointer += totalargs;
             } else {
@@ -2428,12 +2428,12 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(STORE_ATTR): { 
+        case TARGET(STORE_ATTR): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *owner = TOP();
             PyObject *v = SECOND();
             int err;
-            STACK_SHRINK(2); 
+            STACK_SHRINK(2);
             err = PyObject_SetAttr(owner, name, v);
             Py_DECREF(v);
             Py_DECREF(owner);
@@ -2442,7 +2442,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(DELETE_ATTR): { 
+        case TARGET(DELETE_ATTR): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *owner = POP();
             int err;
@@ -2453,7 +2453,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(STORE_GLOBAL): { 
+        case TARGET(STORE_GLOBAL): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *v = POP();
             int err;
@@ -2464,63 +2464,63 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(DELETE_GLOBAL): { 
+        case TARGET(DELETE_GLOBAL): {
             PyObject *name = GETITEM(names, oparg);
             int err;
             err = PyDict_DelItem(f->f_globals, name);
             if (err != 0) {
-                if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
-                    format_exc_check_arg(tstate, PyExc_NameError, 
-                                         NAME_ERROR_MSG, name); 
-                } 
+                if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
+                    format_exc_check_arg(tstate, PyExc_NameError,
+                                         NAME_ERROR_MSG, name);
+                }
                 goto error;
             }
             DISPATCH();
         }
 
-        case TARGET(LOAD_NAME): { 
+        case TARGET(LOAD_NAME): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *locals = f->f_locals;
             PyObject *v;
             if (locals == NULL) {
-                _PyErr_Format(tstate, PyExc_SystemError, 
-                              "no locals when loading %R", name); 
+                _PyErr_Format(tstate, PyExc_SystemError,
+                              "no locals when loading %R", name);
                 goto error;
             }
             if (PyDict_CheckExact(locals)) {
-                v = PyDict_GetItemWithError(locals, name); 
-                if (v != NULL) { 
-                    Py_INCREF(v); 
-                } 
-                else if (_PyErr_Occurred(tstate)) { 
-                    goto error; 
-                } 
+                v = PyDict_GetItemWithError(locals, name);
+                if (v != NULL) {
+                    Py_INCREF(v);
+                }
+                else if (_PyErr_Occurred(tstate)) {
+                    goto error;
+                }
             }
             else {
                 v = PyObject_GetItem(locals, name);
                 if (v == NULL) {
-                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) 
+                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
                         goto error;
-                    _PyErr_Clear(tstate); 
+                    _PyErr_Clear(tstate);
                 }
             }
             if (v == NULL) {
-                v = PyDict_GetItemWithError(f->f_globals, name); 
-                if (v != NULL) { 
-                    Py_INCREF(v); 
-                } 
-                else if (_PyErr_Occurred(tstate)) { 
-                    goto error; 
-                } 
-                else { 
+                v = PyDict_GetItemWithError(f->f_globals, name);
+                if (v != NULL) {
+                    Py_INCREF(v);
+                }
+                else if (_PyErr_Occurred(tstate)) {
+                    goto error;
+                }
+                else {
                     if (PyDict_CheckExact(f->f_builtins)) {
-                        v = PyDict_GetItemWithError(f->f_builtins, name); 
+                        v = PyDict_GetItemWithError(f->f_builtins, name);
                         if (v == NULL) {
-                            if (!_PyErr_Occurred(tstate)) { 
-                                format_exc_check_arg( 
-                                        tstate, PyExc_NameError, 
+                            if (!_PyErr_Occurred(tstate)) {
+                                format_exc_check_arg(
+                                        tstate, PyExc_NameError,
                                         NAME_ERROR_MSG, name);
-                            } 
+                            }
                             goto error;
                         }
                         Py_INCREF(v);
@@ -2528,11 +2528,11 @@ main_loop:
                     else {
                         v = PyObject_GetItem(f->f_builtins, name);
                         if (v == NULL) {
-                            if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
+                            if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
                                 format_exc_check_arg(
-                                            tstate, PyExc_NameError, 
+                                            tstate, PyExc_NameError,
                                             NAME_ERROR_MSG, name);
-                            } 
+                            }
                             goto error;
                         }
                     }
@@ -2542,31 +2542,31 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(LOAD_GLOBAL): { 
-            PyObject *name; 
+        case TARGET(LOAD_GLOBAL): {
+            PyObject *name;
             PyObject *v;
             if (PyDict_CheckExact(f->f_globals)
                 && PyDict_CheckExact(f->f_builtins))
             {
-                OPCACHE_CHECK(); 
-                if (co_opcache != NULL && co_opcache->optimized > 0) { 
-                    _PyOpcache_LoadGlobal *lg = &co_opcache->u.lg; 
- 
-                    if (lg->globals_ver == 
-                            ((PyDictObject *)f->f_globals)->ma_version_tag 
-                        && lg->builtins_ver == 
-                           ((PyDictObject *)f->f_builtins)->ma_version_tag) 
-                    { 
-                        PyObject *ptr = lg->ptr; 
-                        OPCACHE_STAT_GLOBAL_HIT(); 
-                        assert(ptr != NULL); 
-                        Py_INCREF(ptr); 
-                        PUSH(ptr); 
-                        DISPATCH(); 
-                    } 
-                } 
- 
-                name = GETITEM(names, oparg); 
+                OPCACHE_CHECK();
+                if (co_opcache != NULL && co_opcache->optimized > 0) {
+                    _PyOpcache_LoadGlobal *lg = &co_opcache->u.lg;
+
+                    if (lg->globals_ver ==
+                            ((PyDictObject *)f->f_globals)->ma_version_tag
+                        && lg->builtins_ver ==
+                           ((PyDictObject *)f->f_builtins)->ma_version_tag)
+                    {
+                        PyObject *ptr = lg->ptr;
+                        OPCACHE_STAT_GLOBAL_HIT();
+                        assert(ptr != NULL);
+                        Py_INCREF(ptr);
+                        PUSH(ptr);
+                        DISPATCH();
+                    }
+                }
+
+                name = GETITEM(names, oparg);
                 v = _PyDict_LoadGlobal((PyDictObject *)f->f_globals,
                                        (PyDictObject *)f->f_builtins,
                                        name);
@@ -2574,52 +2574,52 @@ main_loop:
                     if (!_PyErr_OCCURRED()) {
                         /* _PyDict_LoadGlobal() returns NULL without raising
                          * an exception if the key doesn't exist */
-                        format_exc_check_arg(tstate, PyExc_NameError, 
+                        format_exc_check_arg(tstate, PyExc_NameError,
                                              NAME_ERROR_MSG, name);
                     }
                     goto error;
                 }
- 
-                if (co_opcache != NULL) { 
-                    _PyOpcache_LoadGlobal *lg = &co_opcache->u.lg; 
- 
-                    if (co_opcache->optimized == 0) { 
-                        /* Wasn't optimized before. */ 
-                        OPCACHE_STAT_GLOBAL_OPT(); 
-                    } else { 
-                        OPCACHE_STAT_GLOBAL_MISS(); 
-                    } 
- 
-                    co_opcache->optimized = 1; 
-                    lg->globals_ver = 
-                        ((PyDictObject *)f->f_globals)->ma_version_tag; 
-                    lg->builtins_ver = 
-                        ((PyDictObject *)f->f_builtins)->ma_version_tag; 
-                    lg->ptr = v; /* borrowed */ 
-                } 
- 
+
+                if (co_opcache != NULL) {
+                    _PyOpcache_LoadGlobal *lg = &co_opcache->u.lg;
+
+                    if (co_opcache->optimized == 0) {
+                        /* Wasn't optimized before. */
+                        OPCACHE_STAT_GLOBAL_OPT();
+                    } else {
+                        OPCACHE_STAT_GLOBAL_MISS();
+                    }
+
+                    co_opcache->optimized = 1;
+                    lg->globals_ver =
+                        ((PyDictObject *)f->f_globals)->ma_version_tag;
+                    lg->builtins_ver =
+                        ((PyDictObject *)f->f_builtins)->ma_version_tag;
+                    lg->ptr = v; /* borrowed */
+                }
+
                 Py_INCREF(v);
             }
             else {
                 /* Slow-path if globals or builtins is not a dict */
 
                 /* namespace 1: globals */
-                name = GETITEM(names, oparg); 
+                name = GETITEM(names, oparg);
                 v = PyObject_GetItem(f->f_globals, name);
                 if (v == NULL) {
-                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
+                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
                         goto error;
-                    } 
-                    _PyErr_Clear(tstate); 
+                    }
+                    _PyErr_Clear(tstate);
 
                     /* namespace 2: builtins */
                     v = PyObject_GetItem(f->f_builtins, name);
                     if (v == NULL) {
-                        if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
+                        if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
                             format_exc_check_arg(
-                                        tstate, PyExc_NameError, 
+                                        tstate, PyExc_NameError,
                                         NAME_ERROR_MSG, name);
-                        } 
+                        }
                         goto error;
                     }
                 }
@@ -2628,21 +2628,21 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(DELETE_FAST): { 
+        case TARGET(DELETE_FAST): {
             PyObject *v = GETLOCAL(oparg);
             if (v != NULL) {
                 SETLOCAL(oparg, NULL);
                 DISPATCH();
             }
             format_exc_check_arg(
-                tstate, PyExc_UnboundLocalError, 
+                tstate, PyExc_UnboundLocalError,
                 UNBOUNDLOCAL_ERROR_MSG,
                 PyTuple_GetItem(co->co_varnames, oparg)
                 );
             goto error;
         }
 
-        case TARGET(DELETE_DEREF): { 
+        case TARGET(DELETE_DEREF): {
             PyObject *cell = freevars[oparg];
             PyObject *oldobj = PyCell_GET(cell);
             if (oldobj != NULL) {
@@ -2650,18 +2650,18 @@ main_loop:
                 Py_DECREF(oldobj);
                 DISPATCH();
             }
-            format_exc_unbound(tstate, co, oparg); 
+            format_exc_unbound(tstate, co, oparg);
             goto error;
         }
 
-        case TARGET(LOAD_CLOSURE): { 
+        case TARGET(LOAD_CLOSURE): {
             PyObject *cell = freevars[oparg];
             Py_INCREF(cell);
             PUSH(cell);
             DISPATCH();
         }
 
-        case TARGET(LOAD_CLASSDEREF): { 
+        case TARGET(LOAD_CLASSDEREF): {
             PyObject *name, *value, *locals = f->f_locals;
             Py_ssize_t idx;
             assert(locals);
@@ -2670,28 +2670,28 @@ main_loop:
             assert(idx >= 0 && idx < PyTuple_GET_SIZE(co->co_freevars));
             name = PyTuple_GET_ITEM(co->co_freevars, idx);
             if (PyDict_CheckExact(locals)) {
-                value = PyDict_GetItemWithError(locals, name); 
-                if (value != NULL) { 
-                    Py_INCREF(value); 
-                } 
-                else if (_PyErr_Occurred(tstate)) { 
-                    goto error; 
-                } 
+                value = PyDict_GetItemWithError(locals, name);
+                if (value != NULL) {
+                    Py_INCREF(value);
+                }
+                else if (_PyErr_Occurred(tstate)) {
+                    goto error;
+                }
             }
             else {
                 value = PyObject_GetItem(locals, name);
                 if (value == NULL) {
-                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
+                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
                         goto error;
-                    } 
-                    _PyErr_Clear(tstate); 
+                    }
+                    _PyErr_Clear(tstate);
                 }
             }
             if (!value) {
                 PyObject *cell = freevars[oparg];
                 value = PyCell_GET(cell);
                 if (value == NULL) {
-                    format_exc_unbound(tstate, co, oparg); 
+                    format_exc_unbound(tstate, co, oparg);
                     goto error;
                 }
                 Py_INCREF(value);
@@ -2700,11 +2700,11 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(LOAD_DEREF): { 
+        case TARGET(LOAD_DEREF): {
             PyObject *cell = freevars[oparg];
             PyObject *value = PyCell_GET(cell);
             if (value == NULL) {
-                format_exc_unbound(tstate, co, oparg); 
+                format_exc_unbound(tstate, co, oparg);
                 goto error;
             }
             Py_INCREF(value);
@@ -2712,7 +2712,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(STORE_DEREF): { 
+        case TARGET(STORE_DEREF): {
             PyObject *v = POP();
             PyObject *cell = freevars[oparg];
             PyObject *oldobj = PyCell_GET(cell);
@@ -2721,7 +2721,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BUILD_STRING): { 
+        case TARGET(BUILD_STRING): {
             PyObject *str;
             PyObject *empty = PyUnicode_New(0, 0);
             if (empty == NULL) {
@@ -2739,7 +2739,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BUILD_TUPLE): { 
+        case TARGET(BUILD_TUPLE): {
             PyObject *tup = PyTuple_New(oparg);
             if (tup == NULL)
                 goto error;
@@ -2751,7 +2751,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BUILD_LIST): { 
+        case TARGET(BUILD_LIST): {
             PyObject *list =  PyList_New(oparg);
             if (list == NULL)
                 goto error;
@@ -2763,50 +2763,50 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(LIST_TO_TUPLE): { 
-            PyObject *list = POP(); 
-            PyObject *tuple = PyList_AsTuple(list); 
-            Py_DECREF(list); 
-            if (tuple == NULL) { 
+        case TARGET(LIST_TO_TUPLE): {
+            PyObject *list = POP();
+            PyObject *tuple = PyList_AsTuple(list);
+            Py_DECREF(list);
+            if (tuple == NULL) {
                 goto error;
-            } 
-            PUSH(tuple); 
-            DISPATCH(); 
-        } 
-
-        case TARGET(LIST_EXTEND): { 
-            PyObject *iterable = POP(); 
-            PyObject *list = PEEK(oparg); 
-            PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); 
-            if (none_val == NULL) { 
-                if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) && 
-                   (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) 
-                { 
-                    _PyErr_Clear(tstate); 
-                    _PyErr_Format(tstate, PyExc_TypeError, 
-                          "Value after * must be an iterable, not %.200s", 
-                          Py_TYPE(iterable)->tp_name); 
+            }
+            PUSH(tuple);
+            DISPATCH();
+        }
+
+        case TARGET(LIST_EXTEND): {
+            PyObject *iterable = POP();
+            PyObject *list = PEEK(oparg);
+            PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
+            if (none_val == NULL) {
+                if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
+                   (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
+                {
+                    _PyErr_Clear(tstate);
+                    _PyErr_Format(tstate, PyExc_TypeError,
+                          "Value after * must be an iterable, not %.200s",
+                          Py_TYPE(iterable)->tp_name);
                 }
-                Py_DECREF(iterable); 
-                goto error; 
-            }
-            Py_DECREF(none_val); 
-            Py_DECREF(iterable); 
-            DISPATCH(); 
-        } 
-
-        case TARGET(SET_UPDATE): { 
-            PyObject *iterable = POP(); 
-            PyObject *set = PEEK(oparg); 
-            int err = _PySet_Update(set, iterable); 
-            Py_DECREF(iterable); 
-            if (err < 0) { 
-                goto error; 
+                Py_DECREF(iterable);
+                goto error;
             }
+            Py_DECREF(none_val);
+            Py_DECREF(iterable);
             DISPATCH();
         }
 
-        case TARGET(BUILD_SET): { 
+        case TARGET(SET_UPDATE): {
+            PyObject *iterable = POP();
+            PyObject *set = PEEK(oparg);
+            int err = _PySet_Update(set, iterable);
+            Py_DECREF(iterable);
+            if (err < 0) {
+                goto error;
+            }
+            DISPATCH();
+        }
+
+        case TARGET(BUILD_SET): {
             PyObject *set = PySet_New(NULL);
             int err = 0;
             int i;
@@ -2818,7 +2818,7 @@ main_loop:
                     err = PySet_Add(set, item);
                 Py_DECREF(item);
             }
-            STACK_SHRINK(oparg); 
+            STACK_SHRINK(oparg);
             if (err != 0) {
                 Py_DECREF(set);
                 goto error;
@@ -2827,7 +2827,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BUILD_MAP): { 
+        case TARGET(BUILD_MAP): {
             Py_ssize_t i;
             PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg);
             if (map == NULL)
@@ -2851,23 +2851,23 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(SETUP_ANNOTATIONS): { 
+        case TARGET(SETUP_ANNOTATIONS): {
             _Py_IDENTIFIER(__annotations__);
             int err;
             PyObject *ann_dict;
             if (f->f_locals == NULL) {
-                _PyErr_Format(tstate, PyExc_SystemError, 
-                              "no locals found when setting up annotations"); 
+                _PyErr_Format(tstate, PyExc_SystemError,
+                              "no locals found when setting up annotations");
                 goto error;
             }
             /* check if __annotations__ in locals()... */
             if (PyDict_CheckExact(f->f_locals)) {
-                ann_dict = _PyDict_GetItemIdWithError(f->f_locals, 
+                ann_dict = _PyDict_GetItemIdWithError(f->f_locals,
                                              &PyId___annotations__);
                 if (ann_dict == NULL) {
-                    if (_PyErr_Occurred(tstate)) { 
-                        goto error; 
-                    } 
+                    if (_PyErr_Occurred(tstate)) {
+                        goto error;
+                    }
                     /* ...if not, create a new one */
                     ann_dict = PyDict_New();
                     if (ann_dict == NULL) {
@@ -2889,10 +2889,10 @@ main_loop:
                 }
                 ann_dict = PyObject_GetItem(f->f_locals, ann_str);
                 if (ann_dict == NULL) {
-                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
+                    if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
                         goto error;
                     }
-                    _PyErr_Clear(tstate); 
+                    _PyErr_Clear(tstate);
                     ann_dict = PyDict_New();
                     if (ann_dict == NULL) {
                         goto error;
@@ -2910,14 +2910,14 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BUILD_CONST_KEY_MAP): { 
+        case TARGET(BUILD_CONST_KEY_MAP): {
             Py_ssize_t i;
             PyObject *map;
             PyObject *keys = TOP();
             if (!PyTuple_CheckExact(keys) ||
                 PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) {
-                _PyErr_SetString(tstate, PyExc_SystemError, 
-                                 "bad BUILD_CONST_KEY_MAP keys argument"); 
+                _PyErr_SetString(tstate, PyExc_SystemError,
+                                 "bad BUILD_CONST_KEY_MAP keys argument");
                 goto error;
             }
             map = _PyDict_NewPresized((Py_ssize_t)oparg);
@@ -2943,42 +2943,42 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(DICT_UPDATE): { 
-            PyObject *update = POP(); 
-            PyObject *dict = PEEK(oparg); 
-            if (PyDict_Update(dict, update) < 0) { 
-                if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) { 
-                    _PyErr_Format(tstate, PyExc_TypeError, 
-                                    "'%.200s' object is not a mapping", 
-                                    Py_TYPE(update)->tp_name); 
-                } 
-                Py_DECREF(update); 
+        case TARGET(DICT_UPDATE): {
+            PyObject *update = POP();
+            PyObject *dict = PEEK(oparg);
+            if (PyDict_Update(dict, update) < 0) {
+                if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
+                    _PyErr_Format(tstate, PyExc_TypeError,
+                                    "'%.200s' object is not a mapping",
+                                    Py_TYPE(update)->tp_name);
+                }
+                Py_DECREF(update);
                 goto error;
             }
-            Py_DECREF(update); 
+            Py_DECREF(update);
             DISPATCH();
         }
 
-        case TARGET(DICT_MERGE): { 
-            PyObject *update = POP(); 
-            PyObject *dict = PEEK(oparg); 
- 
-            if (_PyDict_MergeEx(dict, update, 2) < 0) { 
-                format_kwargs_error(tstate, PEEK(2 + oparg), update); 
-                Py_DECREF(update); 
+        case TARGET(DICT_MERGE): {
+            PyObject *update = POP();
+            PyObject *dict = PEEK(oparg);
+
+            if (_PyDict_MergeEx(dict, update, 2) < 0) {
+                format_kwargs_error(tstate, PEEK(2 + oparg), update);
+                Py_DECREF(update);
                 goto error;
             }
-            Py_DECREF(update); 
-            PREDICT(CALL_FUNCTION_EX); 
+            Py_DECREF(update);
+            PREDICT(CALL_FUNCTION_EX);
             DISPATCH();
         }
 
-        case TARGET(MAP_ADD): { 
-            PyObject *value = TOP(); 
-            PyObject *key = SECOND(); 
+        case TARGET(MAP_ADD): {
+            PyObject *value = TOP();
+            PyObject *key = SECOND();
             PyObject *map;
             int err;
-            STACK_SHRINK(2); 
+            STACK_SHRINK(2);
             map = PEEK(oparg);                      /* dict */
             assert(PyDict_CheckExact(map));
             err = PyDict_SetItem(map, key, value);  /* map[key] = value */
@@ -2990,7 +2990,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(LOAD_ATTR): { 
+        case TARGET(LOAD_ATTR): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *owner = TOP();
             PyObject *res = PyObject_GetAttr(owner, name);
@@ -3001,12 +3001,12 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(COMPARE_OP): { 
-            assert(oparg <= Py_GE); 
+        case TARGET(COMPARE_OP): {
+            assert(oparg <= Py_GE);
             PyObject *right = POP();
             PyObject *left = TOP();
-            PyObject *res = PyObject_RichCompare(left, right, oparg); 
-            SET_TOP(res); 
+            PyObject *res = PyObject_RichCompare(left, right, oparg);
+            SET_TOP(res);
             Py_DECREF(left);
             Py_DECREF(right);
             if (res == NULL)
@@ -3016,87 +3016,87 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(IS_OP): { 
-            PyObject *right = POP(); 
-            PyObject *left = TOP(); 
-            int res = (left == right)^oparg; 
-            PyObject *b = res ? Py_True : Py_False; 
-            Py_INCREF(b); 
-            SET_TOP(b); 
-            Py_DECREF(left); 
-            Py_DECREF(right); 
-            PREDICT(POP_JUMP_IF_FALSE); 
-            PREDICT(POP_JUMP_IF_TRUE); 
-            FAST_DISPATCH(); 
-        } 
- 
-        case TARGET(CONTAINS_OP): { 
-            PyObject *right = POP(); 
-            PyObject *left = POP(); 
-            int res = PySequence_Contains(right, left); 
-            Py_DECREF(left); 
-            Py_DECREF(right); 
-            if (res < 0) { 
-                goto error; 
-            } 
-            PyObject *b = (res^oparg) ? Py_True : Py_False; 
-            Py_INCREF(b); 
-            PUSH(b); 
-            PREDICT(POP_JUMP_IF_FALSE); 
-            PREDICT(POP_JUMP_IF_TRUE); 
-            FAST_DISPATCH(); 
-        } 
- 
-#define CANNOT_CATCH_MSG "catching classes that do not inherit from "\ 
-                         "BaseException is not allowed" 
- 
-        case TARGET(JUMP_IF_NOT_EXC_MATCH): { 
-            PyObject *right = POP(); 
-            PyObject *left = POP(); 
-            if (PyTuple_Check(right)) { 
-                Py_ssize_t i, length; 
-                length = PyTuple_GET_SIZE(right); 
-                for (i = 0; i < length; i++) { 
-                    PyObject *exc = PyTuple_GET_ITEM(right, i); 
-                    if (!PyExceptionClass_Check(exc)) { 
-                        _PyErr_SetString(tstate, PyExc_TypeError, 
-                                        CANNOT_CATCH_MSG); 
-                        Py_DECREF(left); 
-                        Py_DECREF(right); 
-                        goto error; 
-                    } 
-                } 
-            } 
-            else { 
-                if (!PyExceptionClass_Check(right)) { 
-                    _PyErr_SetString(tstate, PyExc_TypeError, 
-                                    CANNOT_CATCH_MSG); 
-                    Py_DECREF(left); 
-                    Py_DECREF(right); 
-                    goto error; 
-                } 
-            } 
-            int res = PyErr_GivenExceptionMatches(left, right); 
-            Py_DECREF(left); 
-            Py_DECREF(right); 
-            if (res > 0) { 
-                /* Exception matches -- Do nothing */; 
-            } 
-            else if (res == 0) { 
-                JUMPTO(oparg); 
-            } 
-            else { 
-                goto error; 
-            } 
-            DISPATCH(); 
-        } 
- 
-        case TARGET(IMPORT_NAME): { 
+        case TARGET(IS_OP): {
+            PyObject *right = POP();
+            PyObject *left = TOP();
+            int res = (left == right)^oparg;
+            PyObject *b = res ? Py_True : Py_False;
+            Py_INCREF(b);
+            SET_TOP(b);
+            Py_DECREF(left);
+            Py_DECREF(right);
+            PREDICT(POP_JUMP_IF_FALSE);
+            PREDICT(POP_JUMP_IF_TRUE);
+            FAST_DISPATCH();
+        }
+
+        case TARGET(CONTAINS_OP): {
+            PyObject *right = POP();
+            PyObject *left = POP();
+            int res = PySequence_Contains(right, left);
+            Py_DECREF(left);
+            Py_DECREF(right);
+            if (res < 0) {
+                goto error;
+            }
+            PyObject *b = (res^oparg) ? Py_True : Py_False;
+            Py_INCREF(b);
+            PUSH(b);
+            PREDICT(POP_JUMP_IF_FALSE);
+            PREDICT(POP_JUMP_IF_TRUE);
+            FAST_DISPATCH();
+        }
+
+#define CANNOT_CATCH_MSG "catching classes that do not inherit from "\
+                         "BaseException is not allowed"
+
+        case TARGET(JUMP_IF_NOT_EXC_MATCH): {
+            PyObject *right = POP();
+            PyObject *left = POP();
+            if (PyTuple_Check(right)) {
+                Py_ssize_t i, length;
+                length = PyTuple_GET_SIZE(right);
+                for (i = 0; i < length; i++) {
+                    PyObject *exc = PyTuple_GET_ITEM(right, i);
+                    if (!PyExceptionClass_Check(exc)) {
+                        _PyErr_SetString(tstate, PyExc_TypeError,
+                                        CANNOT_CATCH_MSG);
+                        Py_DECREF(left);
+                        Py_DECREF(right);
+                        goto error;
+                    }
+                }
+            }
+            else {
+                if (!PyExceptionClass_Check(right)) {
+                    _PyErr_SetString(tstate, PyExc_TypeError,
+                                    CANNOT_CATCH_MSG);
+                    Py_DECREF(left);
+                    Py_DECREF(right);
+                    goto error;
+                }
+            }
+            int res = PyErr_GivenExceptionMatches(left, right);
+            Py_DECREF(left);
+            Py_DECREF(right);
+            if (res > 0) {
+                /* Exception matches -- Do nothing */;
+            }
+            else if (res == 0) {
+                JUMPTO(oparg);
+            }
+            else {
+                goto error;
+            }
+            DISPATCH();
+        }
+
+        case TARGET(IMPORT_NAME): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *fromlist = POP();
             PyObject *level = TOP();
             PyObject *res;
-            res = import_name(tstate, f, name, fromlist, level); 
+            res = import_name(tstate, f, name, fromlist, level);
             Py_DECREF(level);
             Py_DECREF(fromlist);
             SET_TOP(res);
@@ -3105,7 +3105,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(IMPORT_STAR): { 
+        case TARGET(IMPORT_STAR): {
             PyObject *from = POP(), *locals;
             int err;
             if (PyFrame_FastToLocalsWithError(f) < 0) {
@@ -3115,12 +3115,12 @@ main_loop:
 
             locals = f->f_locals;
             if (locals == NULL) {
-                _PyErr_SetString(tstate, PyExc_SystemError, 
-                                 "no locals found during 'import *'"); 
+                _PyErr_SetString(tstate, PyExc_SystemError,
+                                 "no locals found during 'import *'");
                 Py_DECREF(from);
                 goto error;
             }
-            err = import_all_from(tstate, locals, from); 
+            err = import_all_from(tstate, locals, from);
             PyFrame_LocalsToFast(f, 0);
             Py_DECREF(from);
             if (err != 0)
@@ -3128,24 +3128,24 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(IMPORT_FROM): { 
+        case TARGET(IMPORT_FROM): {
             PyObject *name = GETITEM(names, oparg);
             PyObject *from = TOP();
             PyObject *res;
-            res = import_from(tstate, from, name); 
+            res = import_from(tstate, from, name);
             PUSH(res);
             if (res == NULL)
                 goto error;
             DISPATCH();
         }
 
-        case TARGET(JUMP_FORWARD): { 
+        case TARGET(JUMP_FORWARD): {
             JUMPBY(oparg);
             FAST_DISPATCH();
         }
 
-        case TARGET(POP_JUMP_IF_FALSE): { 
-            PREDICTED(POP_JUMP_IF_FALSE); 
+        case TARGET(POP_JUMP_IF_FALSE): {
+            PREDICTED(POP_JUMP_IF_FALSE);
             PyObject *cond = POP();
             int err;
             if (cond == Py_True) {
@@ -3168,8 +3168,8 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(POP_JUMP_IF_TRUE): { 
-            PREDICTED(POP_JUMP_IF_TRUE); 
+        case TARGET(POP_JUMP_IF_TRUE): {
+            PREDICTED(POP_JUMP_IF_TRUE);
             PyObject *cond = POP();
             int err;
             if (cond == Py_False) {
@@ -3193,11 +3193,11 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(JUMP_IF_FALSE_OR_POP): { 
+        case TARGET(JUMP_IF_FALSE_OR_POP): {
             PyObject *cond = TOP();
             int err;
             if (cond == Py_True) {
-                STACK_SHRINK(1); 
+                STACK_SHRINK(1);
                 Py_DECREF(cond);
                 FAST_DISPATCH();
             }
@@ -3207,7 +3207,7 @@ main_loop:
             }
             err = PyObject_IsTrue(cond);
             if (err > 0) {
-                STACK_SHRINK(1); 
+                STACK_SHRINK(1);
                 Py_DECREF(cond);
             }
             else if (err == 0)
@@ -3217,11 +3217,11 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(JUMP_IF_TRUE_OR_POP): { 
+        case TARGET(JUMP_IF_TRUE_OR_POP): {
             PyObject *cond = TOP();
             int err;
             if (cond == Py_False) {
-                STACK_SHRINK(1); 
+                STACK_SHRINK(1);
                 Py_DECREF(cond);
                 FAST_DISPATCH();
             }
@@ -3234,7 +3234,7 @@ main_loop:
                 JUMPTO(oparg);
             }
             else if (err == 0) {
-                STACK_SHRINK(1); 
+                STACK_SHRINK(1);
                 Py_DECREF(cond);
             }
             else
@@ -3242,8 +3242,8 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(JUMP_ABSOLUTE): { 
-            PREDICTED(JUMP_ABSOLUTE); 
+        case TARGET(JUMP_ABSOLUTE): {
+            PREDICTED(JUMP_ABSOLUTE);
             JUMPTO(oparg);
 #if FAST_LOOPS
             /* Enabling this path speeds-up all while and for-loops by bypassing
@@ -3259,7 +3259,7 @@ main_loop:
 #endif
         }
 
-        case TARGET(GET_ITER): { 
+        case TARGET(GET_ITER): {
             /* before: [obj]; after [getiter(obj)] */
             PyObject *iterable = TOP();
             PyObject *iter = PyObject_GetIter(iterable);
@@ -3272,7 +3272,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(GET_YIELD_FROM_ITER): { 
+        case TARGET(GET_YIELD_FROM_ITER): {
             /* before: [obj]; after [getiter(obj)] */
             PyObject *iterable = TOP();
             PyObject *iter;
@@ -3283,9 +3283,9 @@ main_loop:
                        regular generator. */
                     Py_DECREF(iterable);
                     SET_TOP(NULL);
-                    _PyErr_SetString(tstate, PyExc_TypeError, 
-                                     "cannot 'yield from' a coroutine object " 
-                                     "in a non-coroutine generator"); 
+                    _PyErr_SetString(tstate, PyExc_TypeError,
+                                     "cannot 'yield from' a coroutine object "
+                                     "in a non-coroutine generator");
                     goto error;
                 }
             }
@@ -3301,54 +3301,54 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(FOR_ITER): { 
-            PREDICTED(FOR_ITER); 
+        case TARGET(FOR_ITER): {
+            PREDICTED(FOR_ITER);
             /* before: [iter]; after: [iter, iter()] *or* [] */
             PyObject *iter = TOP();
-            PyObject *next = (*Py_TYPE(iter)->tp_iternext)(iter); 
+            PyObject *next = (*Py_TYPE(iter)->tp_iternext)(iter);
             if (next != NULL) {
                 PUSH(next);
                 PREDICT(STORE_FAST);
                 PREDICT(UNPACK_SEQUENCE);
                 DISPATCH();
             }
-            if (_PyErr_Occurred(tstate)) { 
-                if (!_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) { 
+            if (_PyErr_Occurred(tstate)) {
+                if (!_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) {
                     goto error;
-                } 
-                else if (tstate->c_tracefunc != NULL) { 
+                }
+                else if (tstate->c_tracefunc != NULL) {
                     call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f);
-                } 
-                _PyErr_Clear(tstate); 
+                }
+                _PyErr_Clear(tstate);
             }
             /* iterator ended normally */
-            STACK_SHRINK(1); 
+            STACK_SHRINK(1);
             Py_DECREF(iter);
             JUMPBY(oparg);
             PREDICT(POP_BLOCK);
             DISPATCH();
         }
 
-        case TARGET(SETUP_FINALLY): { 
-            PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg, 
+        case TARGET(SETUP_FINALLY): {
+            PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg,
                                STACK_LEVEL());
             DISPATCH();
         }
 
-        case TARGET(BEFORE_ASYNC_WITH): { 
-            _Py_IDENTIFIER(__aenter__); 
+        case TARGET(BEFORE_ASYNC_WITH): {
+            _Py_IDENTIFIER(__aenter__);
             _Py_IDENTIFIER(__aexit__);
             PyObject *mgr = TOP();
-            PyObject *enter = special_lookup(tstate, mgr, &PyId___aenter__); 
+            PyObject *enter = special_lookup(tstate, mgr, &PyId___aenter__);
             PyObject *res;
-            if (enter == NULL) { 
+            if (enter == NULL) {
                 goto error;
-            } 
-            PyObject *exit = special_lookup(tstate, mgr, &PyId___aexit__); 
-            if (exit == NULL) { 
-                Py_DECREF(enter); 
-                goto error; 
-            } 
+            }
+            PyObject *exit = special_lookup(tstate, mgr, &PyId___aexit__);
+            if (exit == NULL) {
+                Py_DECREF(enter);
+                goto error;
+            }
             SET_TOP(exit);
             Py_DECREF(mgr);
             res = _PyObject_CallNoArg(enter);
@@ -3360,7 +3360,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(SETUP_ASYNC_WITH): { 
+        case TARGET(SETUP_ASYNC_WITH): {
             PyObject *res = POP();
             /* Setup the finally block before pushing the result
                of __aenter__ on the stack. */
@@ -3370,16 +3370,16 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(SETUP_WITH): { 
-            _Py_IDENTIFIER(__enter__); 
+        case TARGET(SETUP_WITH): {
+            _Py_IDENTIFIER(__enter__);
             _Py_IDENTIFIER(__exit__);
             PyObject *mgr = TOP();
-            PyObject *enter = special_lookup(tstate, mgr, &PyId___enter__); 
+            PyObject *enter = special_lookup(tstate, mgr, &PyId___enter__);
             PyObject *res;
-            if (enter == NULL) { 
+            if (enter == NULL) {
                 goto error;
-            } 
-            PyObject *exit = special_lookup(tstate, mgr, &PyId___exit__); 
+            }
+            PyObject *exit = special_lookup(tstate, mgr, &PyId___exit__);
             if (exit == NULL) {
                 Py_DECREF(enter);
                 goto error;
@@ -3399,27 +3399,27 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(WITH_EXCEPT_START): { 
-            /* At the top of the stack are 7 values: 
+        case TARGET(WITH_EXCEPT_START): {
+            /* At the top of the stack are 7 values:
                - (TOP, SECOND, THIRD) = exc_info()
-               - (FOURTH, FIFTH, SIXTH) = previous exception for EXCEPT_HANDLER 
-               - SEVENTH: the context.__exit__ bound method 
-               We call SEVENTH(TOP, SECOND, THIRD). 
-               Then we push again the TOP exception and the __exit__ 
-               return value. 
+               - (FOURTH, FIFTH, SIXTH) = previous exception for EXCEPT_HANDLER
+               - SEVENTH: the context.__exit__ bound method
+               We call SEVENTH(TOP, SECOND, THIRD).
+               Then we push again the TOP exception and the __exit__
+               return value.
             */
             PyObject *exit_func;
             PyObject *exc, *val, *tb, *res;
 
             exc = TOP();
-            val = SECOND(); 
-            tb = THIRD(); 
-            assert(exc != Py_None); 
-            assert(!PyLong_Check(exc)); 
-            exit_func = PEEK(7); 
-            PyObject *stack[4] = {NULL, exc, val, tb}; 
-            res = PyObject_Vectorcall(exit_func, stack + 1, 
-                    3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); 
+            val = SECOND();
+            tb = THIRD();
+            assert(exc != Py_None);
+            assert(!PyLong_Check(exc));
+            exit_func = PEEK(7);
+            PyObject *stack[4] = {NULL, exc, val, tb};
+            res = PyObject_Vectorcall(exit_func, stack + 1,
+                    3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
             if (res == NULL)
                 goto error;
 
@@ -3427,8 +3427,8 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(LOAD_METHOD): { 
-            /* Designed to work in tandem with CALL_METHOD. */ 
+        case TARGET(LOAD_METHOD): {
+            /* Designed to work in tandem with CALL_METHOD. */
             PyObject *name = GETITEM(names, oparg);
             PyObject *obj = TOP();
             PyObject *meth = NULL;
@@ -3464,7 +3464,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(CALL_METHOD): { 
+        case TARGET(CALL_METHOD): {
             /* Designed to work in tamdem with LOAD_METHOD. */
             PyObject **sp, *res, *meth;
 
@@ -3486,7 +3486,7 @@ main_loop:
                    `callable` will be POPed by call_function.
                    NULL will will be POPed manually later.
                 */
-                res = call_function(tstate, &sp, oparg, NULL); 
+                res = call_function(tstate, &sp, oparg, NULL);
                 stack_pointer = sp;
                 (void)POP(); /* POP the NULL. */
             }
@@ -3503,7 +3503,7 @@ main_loop:
                   We'll be passing `oparg + 1` to call_function, to
                   make it accept the `self` as a first argument.
                 */
-                res = call_function(tstate, &sp, oparg + 1, NULL); 
+                res = call_function(tstate, &sp, oparg + 1, NULL);
                 stack_pointer = sp;
             }
 
@@ -3513,11 +3513,11 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(CALL_FUNCTION): { 
-            PREDICTED(CALL_FUNCTION); 
+        case TARGET(CALL_FUNCTION): {
+            PREDICTED(CALL_FUNCTION);
             PyObject **sp, *res;
             sp = stack_pointer;
-            res = call_function(tstate, &sp, oparg, NULL); 
+            res = call_function(tstate, &sp, oparg, NULL);
             stack_pointer = sp;
             PUSH(res);
             if (res == NULL) {
@@ -3526,15 +3526,15 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(CALL_FUNCTION_KW): { 
+        case TARGET(CALL_FUNCTION_KW): {
             PyObject **sp, *res, *names;
 
             names = POP();
-            assert(PyTuple_Check(names)); 
-            assert(PyTuple_GET_SIZE(names) <= oparg); 
-            /* We assume without checking that names contains only strings */ 
+            assert(PyTuple_Check(names));
+            assert(PyTuple_GET_SIZE(names) <= oparg);
+            /* We assume without checking that names contains only strings */
             sp = stack_pointer;
-            res = call_function(tstate, &sp, oparg, names); 
+            res = call_function(tstate, &sp, oparg, names);
             stack_pointer = sp;
             PUSH(res);
             Py_DECREF(names);
@@ -3545,8 +3545,8 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(CALL_FUNCTION_EX): { 
-            PREDICTED(CALL_FUNCTION_EX); 
+        case TARGET(CALL_FUNCTION_EX): {
+            PREDICTED(CALL_FUNCTION_EX);
             PyObject *func, *callargs, *kwargs = NULL, *result;
             if (oparg & 0x01) {
                 kwargs = POP();
@@ -3554,9 +3554,9 @@ main_loop:
                     PyObject *d = PyDict_New();
                     if (d == NULL)
                         goto error;
-                    if (_PyDict_MergeEx(d, kwargs, 2) < 0) { 
+                    if (_PyDict_MergeEx(d, kwargs, 2) < 0) {
                         Py_DECREF(d);
-                        format_kwargs_error(tstate, SECOND(), kwargs); 
+                        format_kwargs_error(tstate, SECOND(), kwargs);
                         Py_DECREF(kwargs);
                         goto error;
                     }
@@ -3568,7 +3568,7 @@ main_loop:
             callargs = POP();
             func = TOP();
             if (!PyTuple_CheckExact(callargs)) {
-                if (check_args_iterable(tstate, func, callargs) < 0) { 
+                if (check_args_iterable(tstate, func, callargs) < 0) {
                     Py_DECREF(callargs);
                     goto error;
                 }
@@ -3579,7 +3579,7 @@ main_loop:
             }
             assert(PyTuple_CheckExact(callargs));
 
-            result = do_call_core(tstate, func, callargs, kwargs); 
+            result = do_call_core(tstate, func, callargs, kwargs);
             Py_DECREF(func);
             Py_DECREF(callargs);
             Py_XDECREF(kwargs);
@@ -3591,7 +3591,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(MAKE_FUNCTION): { 
+        case TARGET(MAKE_FUNCTION): {
             PyObject *qualname = POP();
             PyObject *codeobj = POP();
             PyFunctionObject *func = (PyFunctionObject *)
@@ -3624,7 +3624,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(BUILD_SLICE): { 
+        case TARGET(BUILD_SLICE): {
             PyObject *start, *stop, *step, *slice;
             if (oparg == 3)
                 step = POP();
@@ -3642,7 +3642,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(FORMAT_VALUE): { 
+        case TARGET(FORMAT_VALUE): {
             /* Handles f-string value formatting. */
             PyObject *result;
             PyObject *fmt_spec;
@@ -3656,15 +3656,15 @@ main_loop:
 
             /* See if any conversion is specified. */
             switch (which_conversion) {
-            case FVC_NONE:  conv_fn = NULL;           break; 
+            case FVC_NONE:  conv_fn = NULL;           break;
             case FVC_STR:   conv_fn = PyObject_Str;   break;
             case FVC_REPR:  conv_fn = PyObject_Repr;  break;
             case FVC_ASCII: conv_fn = PyObject_ASCII; break;
-            default: 
-                _PyErr_Format(tstate, PyExc_SystemError, 
-                              "unexpected conversion flag %d", 
-                              which_conversion); 
-                goto error; 
+            default:
+                _PyErr_Format(tstate, PyExc_SystemError,
+                              "unexpected conversion flag %d",
+                              which_conversion);
+                goto error;
             }
 
             /* If there's a conversion function, call it and replace
@@ -3702,7 +3702,7 @@ main_loop:
             DISPATCH();
         }
 
-        case TARGET(EXTENDED_ARG): { 
+        case TARGET(EXTENDED_ARG): {
             int oldoparg = oparg;
             NEXTOPARG();
             oparg |= oldoparg << 8;
@@ -3718,7 +3718,7 @@ main_loop:
                 "XXX lineno: %d, opcode: %d\n",
                 PyFrame_GetLineNumber(f),
                 opcode);
-            _PyErr_SetString(tstate, PyExc_SystemError, "unknown opcode"); 
+            _PyErr_SetString(tstate, PyExc_SystemError, "unknown opcode");
             goto error;
 
         } /* switch */
@@ -3730,12 +3730,12 @@ main_loop:
 error:
         /* Double-check exception status. */
 #ifdef NDEBUG
-        if (!_PyErr_Occurred(tstate)) { 
-            _PyErr_SetString(tstate, PyExc_SystemError, 
-                             "error return without exception set"); 
-        } 
+        if (!_PyErr_Occurred(tstate)) {
+            _PyErr_SetString(tstate, PyExc_SystemError,
+                             "error return without exception set");
+        }
 #else
-        assert(_PyErr_Occurred(tstate)); 
+        assert(_PyErr_Occurred(tstate));
 #endif
 
         /* Log traceback info. */
@@ -3745,18 +3745,18 @@ error:
             call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj,
                            tstate, f);
 
-exception_unwind: 
-        /* Unwind stacks if an exception occurred */ 
-        while (f->f_iblock > 0) { 
-            /* Pop the current block. */ 
-            PyTryBlock *b = &f->f_blockstack[--f->f_iblock]; 
+exception_unwind:
+        /* Unwind stacks if an exception occurred */
+        while (f->f_iblock > 0) {
+            /* Pop the current block. */
+            PyTryBlock *b = &f->f_blockstack[--f->f_iblock];
 
             if (b->b_type == EXCEPT_HANDLER) {
                 UNWIND_EXCEPT_HANDLER(b);
                 continue;
             }
             UNWIND_BLOCK(b);
-            if (b->b_type == SETUP_FINALLY) { 
+            if (b->b_type == SETUP_FINALLY) {
                 PyObject *exc, *val, *tb;
                 int handler = b->b_handler;
                 _PyErr_StackItem *exc_info = tstate->exc_info;
@@ -3771,12 +3771,12 @@ exception_unwind:
                     Py_INCREF(Py_None);
                     PUSH(Py_None);
                 }
-                _PyErr_Fetch(tstate, &exc, &val, &tb); 
+                _PyErr_Fetch(tstate, &exc, &val, &tb);
                 /* Make the raw exception data
                    available to the handler,
                    so a program can emulate the
                    Python main loop. */
-                _PyErr_NormalizeException(tstate, &exc, &val, &tb); 
+                _PyErr_NormalizeException(tstate, &exc, &val, &tb);
                 if (tb != NULL)
                     PyException_SetTraceback(val, tb);
                 else
@@ -3793,27 +3793,27 @@ exception_unwind:
                 PUSH(val);
                 PUSH(exc);
                 JUMPTO(handler);
-                if (_Py_TracingPossible(ceval2)) { 
-                    int needs_new_execution_window = (f->f_lasti < instr_lb || f->f_lasti >= instr_ub); 
-                    int needs_line_update = (f->f_lasti == instr_lb || f->f_lasti < instr_prev); 
-                    /* Make sure that we trace line after exception if we are in a new execution 
-                     * window or we don't need a line update and we are not in the first instruction 
-                     * of the line. */ 
-                    if (needs_new_execution_window || (!needs_line_update && instr_lb > 0)) { 
-                        instr_prev = INT_MAX; 
-                    } 
-                } 
-                /* Resume normal execution */ 
-                goto main_loop; 
+                if (_Py_TracingPossible(ceval2)) {
+                    int needs_new_execution_window = (f->f_lasti < instr_lb || f->f_lasti >= instr_ub);
+                    int needs_line_update = (f->f_lasti == instr_lb || f->f_lasti < instr_prev);
+                    /* Make sure that we trace line after exception if we are in a new execution
+                     * window or we don't need a line update and we are not in the first instruction
+                     * of the line. */
+                    if (needs_new_execution_window || (!needs_line_update && instr_lb > 0)) {
+                        instr_prev = INT_MAX;
+                    }
+                }
+                /* Resume normal execution */
+                goto main_loop;
             }
         } /* unwind stack */
 
-        /* End the loop as we still have an error */ 
-        break; 
-    } /* main loop */ 
+        /* End the loop as we still have an error */
+        break;
+    } /* main loop */
 
-    assert(retval == NULL); 
-    assert(_PyErr_Occurred(tstate)); 
+    assert(retval == NULL);
+    assert(_PyErr_Occurred(tstate));
 
     /* Pop remaining stack entries. */
     while (!EMPTY()) {
@@ -3821,17 +3821,17 @@ exception_unwind:
         Py_XDECREF(o);
     }
 
-exiting: 
+exiting:
     if (tstate->use_tracing) {
         if (tstate->c_tracefunc) {
-            if (call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj, 
-                                     tstate, f, PyTrace_RETURN, retval)) { 
-                Py_CLEAR(retval); 
+            if (call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj,
+                                     tstate, f, PyTrace_RETURN, retval)) {
+                Py_CLEAR(retval);
             }
         }
         if (tstate->c_profilefunc) {
-            if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj, 
-                                     tstate, f, PyTrace_RETURN, retval)) { 
+            if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj,
+                                     tstate, f, PyTrace_RETURN, retval)) {
                 Py_CLEAR(retval);
             }
         }
@@ -3841,16 +3841,16 @@ exiting:
 exit_eval_frame:
     if (PyDTrace_FUNCTION_RETURN_ENABLED())
         dtrace_function_return(f);
-    _Py_LeaveRecursiveCall(tstate); 
+    _Py_LeaveRecursiveCall(tstate);
     f->f_executing = 0;
     tstate->frame = f->f_back;
 
-    return _Py_CheckFunctionResult(tstate, NULL, retval, __func__); 
+    return _Py_CheckFunctionResult(tstate, NULL, retval, __func__);
 }
 
 static void
-format_missing(PyThreadState *tstate, const char *kind, 
-               PyCodeObject *co, PyObject *names) 
+format_missing(PyThreadState *tstate, const char *kind,
+               PyCodeObject *co, PyObject *names)
 {
     int err;
     Py_ssize_t len = PyList_GET_SIZE(names);
@@ -3901,19 +3901,19 @@ format_missing(PyThreadState *tstate, const char *kind,
     }
     if (name_str == NULL)
         return;
-    _PyErr_Format(tstate, PyExc_TypeError, 
-                  "%U() missing %i required %s argument%s: %U", 
-                  co->co_name, 
-                  len, 
-                  kind, 
-                  len == 1 ? "" : "s", 
-                  name_str); 
+    _PyErr_Format(tstate, PyExc_TypeError,
+                  "%U() missing %i required %s argument%s: %U",
+                  co->co_name,
+                  len,
+                  kind,
+                  len == 1 ? "" : "s",
+                  name_str);
     Py_DECREF(name_str);
 }
 
 static void
-missing_arguments(PyThreadState *tstate, PyCodeObject *co, 
-                  Py_ssize_t missing, Py_ssize_t defcount, 
+missing_arguments(PyThreadState *tstate, PyCodeObject *co,
+                  Py_ssize_t missing, Py_ssize_t defcount,
                   PyObject **fastlocals)
 {
     Py_ssize_t i, j = 0;
@@ -3946,13 +3946,13 @@ missing_arguments(PyThreadState *tstate, PyCodeObject *co,
         }
     }
     assert(j == missing);
-    format_missing(tstate, kind, co, missing_names); 
+    format_missing(tstate, kind, co, missing_names);
     Py_DECREF(missing_names);
 }
 
 static void
-too_many_positional(PyThreadState *tstate, PyCodeObject *co, 
-                    Py_ssize_t given, Py_ssize_t defcount, 
+too_many_positional(PyThreadState *tstate, PyCodeObject *co,
+                    Py_ssize_t given, Py_ssize_t defcount,
                     PyObject **fastlocals)
 {
     int plural;
@@ -3995,86 +3995,86 @@ too_many_positional(PyThreadState *tstate, PyCodeObject *co,
         kwonly_sig = PyUnicode_FromString("");
         assert(kwonly_sig != NULL);
     }
-    _PyErr_Format(tstate, PyExc_TypeError, 
-                  "%U() takes %U positional argument%s but %zd%U %s given", 
-                  co->co_name, 
-                  sig, 
-                  plural ? "s" : "", 
-                  given, 
-                  kwonly_sig, 
-                  given == 1 && !kwonly_given ? "was" : "were"); 
+    _PyErr_Format(tstate, PyExc_TypeError,
+                  "%U() takes %U positional argument%s but %zd%U %s given",
+                  co->co_name,
+                  sig,
+                  plural ? "s" : "",
+                  given,
+                  kwonly_sig,
+                  given == 1 && !kwonly_given ? "was" : "were");
     Py_DECREF(sig);
     Py_DECREF(kwonly_sig);
 }
 
-static int 
-positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co, 
-                                  Py_ssize_t kwcount, PyObject* const* kwnames) 
-{ 
-    int posonly_conflicts = 0; 
-    PyObject* posonly_names = PyList_New(0); 
- 
-    for(int k=0; k < co->co_posonlyargcount; k++){ 
-        PyObject* posonly_name = PyTuple_GET_ITEM(co->co_varnames, k); 
- 
-        for (int k2=0; k2<kwcount; k2++){ 
-            /* Compare the pointers first and fallback to PyObject_RichCompareBool*/ 
-            PyObject* kwname = kwnames[k2]; 
-            if (kwname == posonly_name){ 
-                if(PyList_Append(posonly_names, kwname) != 0) { 
-                    goto fail; 
-                } 
-                posonly_conflicts++; 
-                continue; 
-            } 
- 
-            int cmp = PyObject_RichCompareBool(posonly_name, kwname, Py_EQ); 
- 
-            if ( cmp > 0) { 
-                if(PyList_Append(posonly_names, kwname) != 0) { 
-                    goto fail; 
-                } 
-                posonly_conflicts++; 
-            } else if (cmp < 0) { 
-                goto fail; 
-            } 
- 
-        } 
-    } 
-    if (posonly_conflicts) { 
-        PyObject* comma = PyUnicode_FromString(", "); 
-        if (comma == NULL) { 
-            goto fail; 
-        } 
-        PyObject* error_names = PyUnicode_Join(comma, posonly_names); 
-        Py_DECREF(comma); 
-        if (error_names == NULL) { 
-            goto fail; 
-        } 
-        _PyErr_Format(tstate, PyExc_TypeError, 
-                      "%U() got some positional-only arguments passed" 
-                      " as keyword arguments: '%U'", 
-                      co->co_name, error_names); 
-        Py_DECREF(error_names); 
-        goto fail; 
-    } 
- 
-    Py_DECREF(posonly_names); 
-    return 0; 
- 
-fail: 
-    Py_XDECREF(posonly_names); 
-    return 1; 
- 
-} 
- 
+static int
+positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co,
+                                  Py_ssize_t kwcount, PyObject* const* kwnames)
+{
+    int posonly_conflicts = 0;
+    PyObject* posonly_names = PyList_New(0);
+
+    for(int k=0; k < co->co_posonlyargcount; k++){
+        PyObject* posonly_name = PyTuple_GET_ITEM(co->co_varnames, k);
+
+        for (int k2=0; k2<kwcount; k2++){
+            /* Compare the pointers first and fallback to PyObject_RichCompareBool*/
+            PyObject* kwname = kwnames[k2];
+            if (kwname == posonly_name){
+                if(PyList_Append(posonly_names, kwname) != 0) {
+                    goto fail;
+                }
+                posonly_conflicts++;
+                continue;
+            }
+
+            int cmp = PyObject_RichCompareBool(posonly_name, kwname, Py_EQ);
+
+            if ( cmp > 0) {
+                if(PyList_Append(posonly_names, kwname) != 0) {
+                    goto fail;
+                }
+                posonly_conflicts++;
+            } else if (cmp < 0) {
+                goto fail;
+            }
+
+        }
+    }
+    if (posonly_conflicts) {
+        PyObject* comma = PyUnicode_FromString(", ");
+        if (comma == NULL) {
+            goto fail;
+        }
+        PyObject* error_names = PyUnicode_Join(comma, posonly_names);
+        Py_DECREF(comma);
+        if (error_names == NULL) {
+            goto fail;
+        }
+        _PyErr_Format(tstate, PyExc_TypeError,
+                      "%U() got some positional-only arguments passed"
+                      " as keyword arguments: '%U'",
+                      co->co_name, error_names);
+        Py_DECREF(error_names);
+        goto fail;
+    }
+
+    Py_DECREF(posonly_names);
+    return 0;
+
+fail:
+    Py_XDECREF(posonly_names);
+    return 1;
+
+}
+
 /* This is gonna seem *real weird*, but if you put some other code between
    PyEval_EvalFrame() and _PyEval_EvalFrameDefault() you will need to adjust
    the test in the if statements in Misc/gdbinit (pystack and pystackv). */
 
 PyObject *
-_PyEval_EvalCode(PyThreadState *tstate, 
-           PyObject *_co, PyObject *globals, PyObject *locals, 
+_PyEval_EvalCode(PyThreadState *tstate,
+           PyObject *_co, PyObject *globals, PyObject *locals,
            PyObject *const *args, Py_ssize_t argcount,
            PyObject *const *kwnames, PyObject *const *kwargs,
            Py_ssize_t kwcount, int kwstep,
@@ -4082,20 +4082,20 @@ _PyEval_EvalCode(PyThreadState *tstate,
            PyObject *kwdefs, PyObject *closure,
            PyObject *name, PyObject *qualname)
 {
-    assert(is_tstate_valid(tstate)); 
- 
+    assert(is_tstate_valid(tstate));
+
     PyCodeObject* co = (PyCodeObject*)_co;
     PyFrameObject *f;
     PyObject *retval = NULL;
     PyObject **fastlocals, **freevars;
     PyObject *x, *u;
     const Py_ssize_t total_args = co->co_argcount + co->co_kwonlyargcount;
-    Py_ssize_t i, j, n; 
+    Py_ssize_t i, j, n;
     PyObject *kwdict;
 
     if (globals == NULL) {
-        _PyErr_SetString(tstate, PyExc_SystemError, 
-                         "PyEval_EvalCodeEx: NULL globals"); 
+        _PyErr_SetString(tstate, PyExc_SystemError,
+                         "PyEval_EvalCodeEx: NULL globals");
         return NULL;
     }
 
@@ -4122,22 +4122,22 @@ _PyEval_EvalCode(PyThreadState *tstate,
         kwdict = NULL;
     }
 
-    /* Copy all positional arguments into local variables */ 
+    /* Copy all positional arguments into local variables */
     if (argcount > co->co_argcount) {
         n = co->co_argcount;
     }
     else {
         n = argcount;
     }
-    for (j = 0; j < n; j++) { 
-        x = args[j]; 
+    for (j = 0; j < n; j++) {
+        x = args[j];
         Py_INCREF(x);
-        SETLOCAL(j, x); 
+        SETLOCAL(j, x);
     }
 
     /* Pack other positional arguments into the *args argument */
     if (co->co_flags & CO_VARARGS) {
-        u = _PyTuple_FromArray(args + n, argcount - n); 
+        u = _PyTuple_FromArray(args + n, argcount - n);
         if (u == NULL) {
             goto fail;
         }
@@ -4153,16 +4153,16 @@ _PyEval_EvalCode(PyThreadState *tstate,
         Py_ssize_t j;
 
         if (keyword == NULL || !PyUnicode_Check(keyword)) {
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "%U() keywords must be strings", 
-                          co->co_name); 
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "%U() keywords must be strings",
+                          co->co_name);
             goto fail;
         }
 
         /* Speed hack: do raw pointer compares. As names are
            normally interned this should almost always hit. */
         co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item;
-        for (j = co->co_posonlyargcount; j < total_args; j++) { 
+        for (j = co->co_posonlyargcount; j < total_args; j++) {
             PyObject *name = co_varnames[j];
             if (name == keyword) {
                 goto kw_found;
@@ -4170,7 +4170,7 @@ _PyEval_EvalCode(PyThreadState *tstate,
         }
 
         /* Slow fallback, just in case */
-        for (j = co->co_posonlyargcount; j < total_args; j++) { 
+        for (j = co->co_posonlyargcount; j < total_args; j++) {
             PyObject *name = co_varnames[j];
             int cmp = PyObject_RichCompareBool( keyword, name, Py_EQ);
             if (cmp > 0) {
@@ -4183,17 +4183,17 @@ _PyEval_EvalCode(PyThreadState *tstate,
 
         assert(j >= total_args);
         if (kwdict == NULL) {
- 
-            if (co->co_posonlyargcount 
-                && positional_only_passed_as_keyword(tstate, co, 
-                                                     kwcount, kwnames)) 
-            { 
-                goto fail; 
-            } 
- 
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "%U() got an unexpected keyword argument '%S'", 
-                          co->co_name, keyword); 
+
+            if (co->co_posonlyargcount
+                && positional_only_passed_as_keyword(tstate, co,
+                                                     kwcount, kwnames))
+            {
+                goto fail;
+            }
+
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "%U() got an unexpected keyword argument '%S'",
+                          co->co_name, keyword);
             goto fail;
         }
 
@@ -4204,9 +4204,9 @@ _PyEval_EvalCode(PyThreadState *tstate,
 
       kw_found:
         if (GETLOCAL(j) != NULL) {
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "%U() got multiple values for argument '%S'", 
-                          co->co_name, keyword); 
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "%U() got multiple values for argument '%S'",
+                          co->co_name, keyword);
             goto fail;
         }
         Py_INCREF(value);
@@ -4214,8 +4214,8 @@ _PyEval_EvalCode(PyThreadState *tstate,
     }
 
     /* Check the number of positional arguments */
-    if ((argcount > co->co_argcount) && !(co->co_flags & CO_VARARGS)) { 
-        too_many_positional(tstate, co, argcount, defcount, fastlocals); 
+    if ((argcount > co->co_argcount) && !(co->co_flags & CO_VARARGS)) {
+        too_many_positional(tstate, co, argcount, defcount, fastlocals);
         goto fail;
     }
 
@@ -4229,7 +4229,7 @@ _PyEval_EvalCode(PyThreadState *tstate,
             }
         }
         if (missing) {
-            missing_arguments(tstate, co, missing, defcount, fastlocals); 
+            missing_arguments(tstate, co, missing, defcount, fastlocals);
             goto fail;
         }
         if (n > m)
@@ -4254,20 +4254,20 @@ _PyEval_EvalCode(PyThreadState *tstate,
                 continue;
             name = PyTuple_GET_ITEM(co->co_varnames, i);
             if (kwdefs != NULL) {
-                PyObject *def = PyDict_GetItemWithError(kwdefs, name); 
+                PyObject *def = PyDict_GetItemWithError(kwdefs, name);
                 if (def) {
                     Py_INCREF(def);
                     SETLOCAL(i, def);
                     continue;
                 }
-                else if (_PyErr_Occurred(tstate)) { 
-                    goto fail; 
-                } 
+                else if (_PyErr_Occurred(tstate)) {
+                    goto fail;
+                }
             }
             missing++;
         }
         if (missing) {
-            missing_arguments(tstate, co, missing, -1, fastlocals); 
+            missing_arguments(tstate, co, missing, -1, fastlocals);
             goto fail;
         }
     }
@@ -4326,7 +4326,7 @@ _PyEval_EvalCode(PyThreadState *tstate,
         return gen;
     }
 
-    retval = _PyEval_EvalFrame(tstate, f, 0); 
+    retval = _PyEval_EvalFrame(tstate, f, 0);
 
 fail: /* Jump here from prelude on failure */
 
@@ -4347,27 +4347,27 @@ fail: /* Jump here from prelude on failure */
     return retval;
 }
 
- 
+
+PyObject *
+_PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals,
+           PyObject *const *args, Py_ssize_t argcount,
+           PyObject *const *kwnames, PyObject *const *kwargs,
+           Py_ssize_t kwcount, int kwstep,
+           PyObject *const *defs, Py_ssize_t defcount,
+           PyObject *kwdefs, PyObject *closure,
+           PyObject *name, PyObject *qualname)
+{
+    PyThreadState *tstate = _PyThreadState_GET();
+    return _PyEval_EvalCode(tstate, _co, globals, locals,
+               args, argcount,
+               kwnames, kwargs,
+               kwcount, kwstep,
+               defs, defcount,
+               kwdefs, closure,
+               name, qualname);
+}
+
 PyObject *
-_PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals, 
-           PyObject *const *args, Py_ssize_t argcount, 
-           PyObject *const *kwnames, PyObject *const *kwargs, 
-           Py_ssize_t kwcount, int kwstep, 
-           PyObject *const *defs, Py_ssize_t defcount, 
-           PyObject *kwdefs, PyObject *closure, 
-           PyObject *name, PyObject *qualname) 
-{ 
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return _PyEval_EvalCode(tstate, _co, globals, locals, 
-               args, argcount, 
-               kwnames, kwargs, 
-               kwcount, kwstep, 
-               defs, defcount, 
-               kwdefs, closure, 
-               name, qualname); 
-} 
- 
-PyObject * 
 PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
                   PyObject *const *args, int argcount,
                   PyObject *const *kws, int kwcount,
@@ -4384,12 +4384,12 @@ PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
 }
 
 static PyObject *
-special_lookup(PyThreadState *tstate, PyObject *o, _Py_Identifier *id) 
+special_lookup(PyThreadState *tstate, PyObject *o, _Py_Identifier *id)
 {
     PyObject *res;
     res = _PyObject_LookupSpecial(o, id);
-    if (res == NULL && !_PyErr_Occurred(tstate)) { 
-        _PyErr_SetObject(tstate, PyExc_AttributeError, _PyUnicode_FromId(id)); 
+    if (res == NULL && !_PyErr_Occurred(tstate)) {
+        _PyErr_SetObject(tstate, PyExc_AttributeError, _PyUnicode_FromId(id));
         return NULL;
     }
     return res;
@@ -4399,7 +4399,7 @@ special_lookup(PyThreadState *tstate, PyObject *o, _Py_Identifier *id)
 /* Logic for the raise statement (too complicated for inlining).
    This *consumes* a reference count to each of its arguments. */
 static int
-do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause) 
+do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
 {
     PyObject *type = NULL, *value = NULL;
 
@@ -4411,14 +4411,14 @@ do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
         value = exc_info->exc_value;
         tb = exc_info->exc_traceback;
         if (type == Py_None || type == NULL) {
-            _PyErr_SetString(tstate, PyExc_RuntimeError, 
-                             "No active exception to reraise"); 
+            _PyErr_SetString(tstate, PyExc_RuntimeError,
+                             "No active exception to reraise");
             return 0;
         }
         Py_XINCREF(type);
         Py_XINCREF(value);
         Py_XINCREF(tb);
-        _PyErr_Restore(tstate, type, value, tb); 
+        _PyErr_Restore(tstate, type, value, tb);
         return 1;
     }
 
@@ -4433,11 +4433,11 @@ do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
         if (value == NULL)
             goto raise_error;
         if (!PyExceptionInstance_Check(value)) {
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "calling %R should have returned an instance of " 
-                          "BaseException, not %R", 
-                          type, Py_TYPE(value)); 
-             goto raise_error; 
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "calling %R should have returned an instance of "
+                          "BaseException, not %R",
+                          type, Py_TYPE(value));
+             goto raise_error;
         }
     }
     else if (PyExceptionInstance_Check(exc)) {
@@ -4449,8 +4449,8 @@ do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
         /* Not something you can raise.  You get an exception
            anyway, just not what you specified :-) */
         Py_DECREF(exc);
-        _PyErr_SetString(tstate, PyExc_TypeError, 
-                         "exceptions must derive from BaseException"); 
+        _PyErr_SetString(tstate, PyExc_TypeError,
+                         "exceptions must derive from BaseException");
         goto raise_error;
     }
 
@@ -4473,16 +4473,16 @@ do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
             fixed_cause = NULL;
         }
         else {
-            _PyErr_SetString(tstate, PyExc_TypeError, 
-                             "exception causes must derive from " 
-                             "BaseException"); 
+            _PyErr_SetString(tstate, PyExc_TypeError,
+                             "exception causes must derive from "
+                             "BaseException");
             goto raise_error;
         }
         PyException_SetCause(value, fixed_cause);
     }
 
-    _PyErr_SetObject(tstate, type, value); 
-    /* _PyErr_SetObject incref's its arguments */ 
+    _PyErr_SetObject(tstate, type, value);
+    /* _PyErr_SetObject incref's its arguments */
     Py_DECREF(value);
     Py_DECREF(type);
     return 0;
@@ -4502,8 +4502,8 @@ raise_error:
 */
 
 static int
-unpack_iterable(PyThreadState *tstate, PyObject *v, 
-                int argcnt, int argcntafter, PyObject **sp) 
+unpack_iterable(PyThreadState *tstate, PyObject *v,
+                int argcnt, int argcntafter, PyObject **sp)
 {
     int i = 0, j = 0;
     Py_ssize_t ll = 0;
@@ -4515,12 +4515,12 @@ unpack_iterable(PyThreadState *tstate, PyObject *v,
 
     it = PyObject_GetIter(v);
     if (it == NULL) {
-        if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) && 
-            Py_TYPE(v)->tp_iter == NULL && !PySequence_Check(v)) 
+        if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
+            Py_TYPE(v)->tp_iter == NULL && !PySequence_Check(v))
         {
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "cannot unpack non-iterable %.200s object", 
-                          Py_TYPE(v)->tp_name); 
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "cannot unpack non-iterable %.200s object",
+                          Py_TYPE(v)->tp_name);
         }
         return 0;
     }
@@ -4529,18 +4529,18 @@ unpack_iterable(PyThreadState *tstate, PyObject *v,
         w = PyIter_Next(it);
         if (w == NULL) {
             /* Iterator done, via error or exhaustion. */
-            if (!_PyErr_Occurred(tstate)) { 
+            if (!_PyErr_Occurred(tstate)) {
                 if (argcntafter == -1) {
-                    _PyErr_Format(tstate, PyExc_ValueError, 
-                                  "not enough values to unpack " 
-                                  "(expected %d, got %d)", 
-                                  argcnt, i); 
+                    _PyErr_Format(tstate, PyExc_ValueError,
+                                  "not enough values to unpack "
+                                  "(expected %d, got %d)",
+                                  argcnt, i);
                 }
                 else {
-                    _PyErr_Format(tstate, PyExc_ValueError, 
-                                  "not enough values to unpack " 
-                                  "(expected at least %d, got %d)", 
-                                  argcnt + argcntafter, i); 
+                    _PyErr_Format(tstate, PyExc_ValueError,
+                                  "not enough values to unpack "
+                                  "(expected at least %d, got %d)",
+                                  argcnt + argcntafter, i);
                 }
             }
             goto Error;
@@ -4552,15 +4552,15 @@ unpack_iterable(PyThreadState *tstate, PyObject *v,
         /* We better have exhausted the iterator now. */
         w = PyIter_Next(it);
         if (w == NULL) {
-            if (_PyErr_Occurred(tstate)) 
+            if (_PyErr_Occurred(tstate))
                 goto Error;
             Py_DECREF(it);
             return 1;
         }
         Py_DECREF(w);
-        _PyErr_Format(tstate, PyExc_ValueError, 
-                      "too many values to unpack (expected %d)", 
-                      argcnt); 
+        _PyErr_Format(tstate, PyExc_ValueError,
+                      "too many values to unpack (expected %d)",
+                      argcnt);
         goto Error;
     }
 
@@ -4572,7 +4572,7 @@ unpack_iterable(PyThreadState *tstate, PyObject *v,
 
     ll = PyList_GET_SIZE(l);
     if (ll < argcntafter) {
-        _PyErr_Format(tstate, PyExc_ValueError, 
+        _PyErr_Format(tstate, PyExc_ValueError,
             "not enough values to unpack (expected at least %d, got %zd)",
             argcnt + argcntafter, argcnt + ll);
         goto Error;
@@ -4583,7 +4583,7 @@ unpack_iterable(PyThreadState *tstate, PyObject *v,
         *--sp = PyList_GET_ITEM(l, ll - j);
     }
     /* Resize the list. */
-    Py_SET_SIZE(l, ll - argcntafter); 
+    Py_SET_SIZE(l, ll - argcntafter);
     Py_DECREF(it);
     return 1;
 
@@ -4597,17 +4597,17 @@ Error:
 
 #ifdef LLTRACE
 static int
-prtrace(PyThreadState *tstate, PyObject *v, const char *str) 
+prtrace(PyThreadState *tstate, PyObject *v, const char *str)
 {
     printf("%s ", str);
-    PyObject *type, *value, *traceback; 
-    PyErr_Fetch(&type, &value, &traceback); 
-    if (PyObject_Print(v, stdout, 0) != 0) { 
-        /* Don't know what else to do */ 
-        _PyErr_Clear(tstate); 
-    } 
+    PyObject *type, *value, *traceback;
+    PyErr_Fetch(&type, &value, &traceback);
+    if (PyObject_Print(v, stdout, 0) != 0) {
+        /* Don't know what else to do */
+        _PyErr_Clear(tstate);
+    }
     printf("\n");
-    PyErr_Restore(type, value, traceback); 
+    PyErr_Restore(type, value, traceback);
     return 1;
 }
 #endif
@@ -4618,23 +4618,23 @@ call_exc_trace(Py_tracefunc func, PyObject *self,
 {
     PyObject *type, *value, *traceback, *orig_traceback, *arg;
     int err;
-    _PyErr_Fetch(tstate, &type, &value, &orig_traceback); 
+    _PyErr_Fetch(tstate, &type, &value, &orig_traceback);
     if (value == NULL) {
         value = Py_None;
         Py_INCREF(value);
     }
-    _PyErr_NormalizeException(tstate, &type, &value, &orig_traceback); 
+    _PyErr_NormalizeException(tstate, &type, &value, &orig_traceback);
     traceback = (orig_traceback != NULL) ? orig_traceback : Py_None;
     arg = PyTuple_Pack(3, type, value, traceback);
     if (arg == NULL) {
-        _PyErr_Restore(tstate, type, value, orig_traceback); 
+        _PyErr_Restore(tstate, type, value, orig_traceback);
         return;
     }
     err = call_trace(func, self, tstate, f, PyTrace_EXCEPTION, arg);
     Py_DECREF(arg);
-    if (err == 0) { 
-        _PyErr_Restore(tstate, type, value, orig_traceback); 
-    } 
+    if (err == 0) {
+        _PyErr_Restore(tstate, type, value, orig_traceback);
+    }
     else {
         Py_XDECREF(type);
         Py_XDECREF(value);
@@ -4649,11 +4649,11 @@ call_trace_protected(Py_tracefunc func, PyObject *obj,
 {
     PyObject *type, *value, *traceback;
     int err;
-    _PyErr_Fetch(tstate, &type, &value, &traceback); 
+    _PyErr_Fetch(tstate, &type, &value, &traceback);
     err = call_trace(func, obj, tstate, frame, what, arg);
     if (err == 0)
     {
-        _PyErr_Restore(tstate, type, value, traceback); 
+        _PyErr_Restore(tstate, type, value, traceback);
         return 0;
     }
     else {
@@ -4684,7 +4684,7 @@ call_trace(Py_tracefunc func, PyObject *obj,
 PyObject *
 _PyEval_CallTracing(PyObject *func, PyObject *args)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
+    PyThreadState *tstate = _PyThreadState_GET();
     int save_tracing = tstate->tracing;
     int save_use_tracing = tstate->use_tracing;
     PyObject *result;
@@ -4735,96 +4735,96 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
     return result;
 }
 
-int 
-_PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg) 
+int
+_PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
 {
-    assert(is_tstate_valid(tstate)); 
-    /* The caller must hold the GIL */ 
-    assert(PyGILState_Check()); 
- 
-    /* Call _PySys_Audit() in the context of the current thread state, 
-       even if tstate is not the current thread state. */ 
-    PyThreadState *current_tstate = _PyThreadState_GET(); 
-    if (_PySys_Audit(current_tstate, "sys.setprofile", NULL) < 0) { 
-        return -1; 
-    } 
- 
-    PyObject *profileobj = tstate->c_profileobj; 
- 
+    assert(is_tstate_valid(tstate));
+    /* The caller must hold the GIL */
+    assert(PyGILState_Check());
+
+    /* Call _PySys_Audit() in the context of the current thread state,
+       even if tstate is not the current thread state. */
+    PyThreadState *current_tstate = _PyThreadState_GET();
+    if (_PySys_Audit(current_tstate, "sys.setprofile", NULL) < 0) {
+        return -1;
+    }
+
+    PyObject *profileobj = tstate->c_profileobj;
+
     tstate->c_profilefunc = NULL;
     tstate->c_profileobj = NULL;
-    /* Must make sure that tracing is not ignored if 'profileobj' is freed */ 
+    /* Must make sure that tracing is not ignored if 'profileobj' is freed */
     tstate->use_tracing = tstate->c_tracefunc != NULL;
-    Py_XDECREF(profileobj); 
- 
-    Py_XINCREF(arg); 
-    tstate->c_profileobj = arg; 
+    Py_XDECREF(profileobj);
+
+    Py_XINCREF(arg);
+    tstate->c_profileobj = arg;
     tstate->c_profilefunc = func;
- 
+
     /* Flag that tracing or profiling is turned on */
     tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
-    return 0; 
+    return 0;
 }
 
 void
-PyEval_SetProfile(Py_tracefunc func, PyObject *arg) 
+PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    if (_PyEval_SetProfile(tstate, func, arg) < 0) { 
-        /* Log _PySys_Audit() error */ 
-        _PyErr_WriteUnraisableMsg("in PyEval_SetProfile", NULL); 
-    } 
-} 
- 
-int 
-_PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg) 
-{ 
-    assert(is_tstate_valid(tstate)); 
-    /* The caller must hold the GIL */ 
-    assert(PyGILState_Check()); 
- 
-    /* Call _PySys_Audit() in the context of the current thread state, 
-       even if tstate is not the current thread state. */ 
-    PyThreadState *current_tstate = _PyThreadState_GET(); 
-    if (_PySys_Audit(current_tstate, "sys.settrace", NULL) < 0) { 
-        return -1; 
-    } 
- 
-    struct _ceval_state *ceval2 = &tstate->interp->ceval; 
-    PyObject *traceobj = tstate->c_traceobj; 
-    ceval2->tracing_possible += (func != NULL) - (tstate->c_tracefunc != NULL); 
- 
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (_PyEval_SetProfile(tstate, func, arg) < 0) {
+        /* Log _PySys_Audit() error */
+        _PyErr_WriteUnraisableMsg("in PyEval_SetProfile", NULL);
+    }
+}
+
+int
+_PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
+{
+    assert(is_tstate_valid(tstate));
+    /* The caller must hold the GIL */
+    assert(PyGILState_Check());
+
+    /* Call _PySys_Audit() in the context of the current thread state,
+       even if tstate is not the current thread state. */
+    PyThreadState *current_tstate = _PyThreadState_GET();
+    if (_PySys_Audit(current_tstate, "sys.settrace", NULL) < 0) {
+        return -1;
+    }
+
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+    PyObject *traceobj = tstate->c_traceobj;
+    ceval2->tracing_possible += (func != NULL) - (tstate->c_tracefunc != NULL);
+
     tstate->c_tracefunc = NULL;
     tstate->c_traceobj = NULL;
-    /* Must make sure that profiling is not ignored if 'traceobj' is freed */ 
-    tstate->use_tracing = (tstate->c_profilefunc != NULL); 
-    Py_XDECREF(traceobj); 
- 
-    Py_XINCREF(arg); 
-    tstate->c_traceobj = arg; 
+    /* Must make sure that profiling is not ignored if 'traceobj' is freed */
+    tstate->use_tracing = (tstate->c_profilefunc != NULL);
+    Py_XDECREF(traceobj);
+
+    Py_XINCREF(arg);
+    tstate->c_traceobj = arg;
     tstate->c_tracefunc = func;
- 
+
     /* Flag that tracing or profiling is turned on */
     tstate->use_tracing = ((func != NULL)
                            || (tstate->c_profilefunc != NULL));
- 
-    return 0; 
+
+    return 0;
+}
+
+void
+PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
+{
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (_PyEval_SetTrace(tstate, func, arg) < 0) {
+        /* Log _PySys_Audit() error */
+        _PyErr_WriteUnraisableMsg("in PyEval_SetTrace", NULL);
+    }
 }
 
+
 void
-PyEval_SetTrace(Py_tracefunc func, PyObject *arg) 
+_PyEval_SetCoroutineOriginTrackingDepth(PyThreadState *tstate, int new_depth)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    if (_PyEval_SetTrace(tstate, func, arg) < 0) { 
-        /* Log _PySys_Audit() error */ 
-        _PyErr_WriteUnraisableMsg("in PyEval_SetTrace", NULL); 
-    } 
-} 
- 
- 
-void 
-_PyEval_SetCoroutineOriginTrackingDepth(PyThreadState *tstate, int new_depth) 
-{ 
     assert(new_depth >= 0);
     tstate->coroutine_origin_tracking_depth = new_depth;
 }
@@ -4832,66 +4832,66 @@ _PyEval_SetCoroutineOriginTrackingDepth(PyThreadState *tstate, int new_depth)
 int
 _PyEval_GetCoroutineOriginTrackingDepth(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
+    PyThreadState *tstate = _PyThreadState_GET();
     return tstate->coroutine_origin_tracking_depth;
 }
 
-int 
-_PyEval_SetAsyncGenFirstiter(PyObject *firstiter) 
-{ 
-    PyThreadState *tstate = _PyThreadState_GET(); 
- 
-    if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_firstiter", NULL) < 0) { 
-        return -1; 
-    } 
- 
-    Py_XINCREF(firstiter); 
-    Py_XSETREF(tstate->async_gen_firstiter, firstiter); 
-    return 0; 
-} 
- 
+int
+_PyEval_SetAsyncGenFirstiter(PyObject *firstiter)
+{
+    PyThreadState *tstate = _PyThreadState_GET();
+
+    if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_firstiter", NULL) < 0) {
+        return -1;
+    }
+
+    Py_XINCREF(firstiter);
+    Py_XSETREF(tstate->async_gen_firstiter, firstiter);
+    return 0;
+}
+
 PyObject *
-_PyEval_GetAsyncGenFirstiter(void) 
+_PyEval_GetAsyncGenFirstiter(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return tstate->async_gen_firstiter; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    return tstate->async_gen_firstiter;
+}
+
+int
+_PyEval_SetAsyncGenFinalizer(PyObject *finalizer)
+{
+    PyThreadState *tstate = _PyThreadState_GET();
+
+    if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_finalizer", NULL) < 0) {
+        return -1;
+    }
+
+    Py_XINCREF(finalizer);
+    Py_XSETREF(tstate->async_gen_finalizer, finalizer);
+    return 0;
 }
 
-int 
-_PyEval_SetAsyncGenFinalizer(PyObject *finalizer) 
-{ 
-    PyThreadState *tstate = _PyThreadState_GET(); 
- 
-    if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_finalizer", NULL) < 0) { 
-        return -1; 
-    } 
- 
-    Py_XINCREF(finalizer); 
-    Py_XSETREF(tstate->async_gen_finalizer, finalizer); 
-    return 0; 
-} 
- 
 PyObject *
-_PyEval_GetAsyncGenFinalizer(void) 
+_PyEval_GetAsyncGenFinalizer(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return tstate->async_gen_finalizer; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    return tstate->async_gen_finalizer;
 }
 
-PyFrameObject * 
-PyEval_GetFrame(void) 
+PyFrameObject *
+PyEval_GetFrame(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    return tstate->frame; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    return tstate->frame;
 }
 
 PyObject *
 PyEval_GetBuiltins(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    PyFrameObject *current_frame = tstate->frame; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyFrameObject *current_frame = tstate->frame;
     if (current_frame == NULL)
-        return tstate->interp->builtins; 
+        return tstate->interp->builtins;
     else
         return current_frame->f_builtins;
 }
@@ -4900,13 +4900,13 @@ PyEval_GetBuiltins(void)
 PyObject *
 _PyEval_GetBuiltinId(_Py_Identifier *name)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
+    PyThreadState *tstate = _PyThreadState_GET();
     PyObject *attr = _PyDict_GetItemIdWithError(PyEval_GetBuiltins(), name);
     if (attr) {
         Py_INCREF(attr);
     }
-    else if (!_PyErr_Occurred(tstate)) { 
-        _PyErr_SetObject(tstate, PyExc_AttributeError, _PyUnicode_FromId(name)); 
+    else if (!_PyErr_Occurred(tstate)) {
+        _PyErr_SetObject(tstate, PyExc_AttributeError, _PyUnicode_FromId(name));
     }
     return attr;
 }
@@ -4914,16 +4914,16 @@ _PyEval_GetBuiltinId(_Py_Identifier *name)
 PyObject *
 PyEval_GetLocals(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    PyFrameObject *current_frame = tstate->frame; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyFrameObject *current_frame = tstate->frame;
     if (current_frame == NULL) {
-        _PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist"); 
+        _PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist");
         return NULL;
     }
 
-    if (PyFrame_FastToLocalsWithError(current_frame) < 0) { 
+    if (PyFrame_FastToLocalsWithError(current_frame) < 0) {
         return NULL;
-    } 
+    }
 
     assert(current_frame->f_locals != NULL);
     return current_frame->f_locals;
@@ -4932,11 +4932,11 @@ PyEval_GetLocals(void)
 PyObject *
 PyEval_GetGlobals(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    PyFrameObject *current_frame = tstate->frame; 
-    if (current_frame == NULL) { 
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyFrameObject *current_frame = tstate->frame;
+    if (current_frame == NULL) {
         return NULL;
-    } 
+    }
 
     assert(current_frame->f_globals != NULL);
     return current_frame->f_globals;
@@ -4945,8 +4945,8 @@ PyEval_GetGlobals(void)
 int
 PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    PyFrameObject *current_frame = tstate->frame; 
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyFrameObject *current_frame = tstate->frame;
     int result = cf->cf_flags != 0;
 
     if (current_frame != NULL) {
@@ -4977,7 +4977,7 @@ PyEval_GetFuncName(PyObject *func)
     else if (PyCFunction_Check(func))
         return ((PyCFunctionObject*)func)->m_ml->ml_name;
     else
-        return Py_TYPE(func)->tp_name; 
+        return Py_TYPE(func)->tp_name;
 }
 
 const char *
@@ -5024,44 +5024,44 @@ if (tstate->use_tracing && tstate->c_profilefunc) { \
     x = call; \
     }
 
- 
-static PyObject * 
-trace_call_function(PyThreadState *tstate, 
-                    PyObject *func, 
-                    PyObject **args, Py_ssize_t nargs, 
-                    PyObject *kwnames) 
-{ 
-    PyObject *x; 
-    if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) { 
-        C_TRACE(x, PyObject_Vectorcall(func, args, nargs, kwnames)); 
-        return x; 
-    } 
-    else if (Py_IS_TYPE(func, &PyMethodDescr_Type) && nargs > 0) { 
-        /* We need to create a temporary bound method as argument 
-           for profiling. 
- 
-           If nargs == 0, then this cannot work because we have no 
-           "self". In any case, the call itself would raise 
-           TypeError (foo needs an argument), so we just skip 
-           profiling. */ 
-        PyObject *self = args[0]; 
-        func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self)); 
-        if (func == NULL) { 
-            return NULL; 
-        } 
-        C_TRACE(x, PyObject_Vectorcall(func, 
-                                        args+1, nargs-1, 
-                                        kwnames)); 
-        Py_DECREF(func); 
-        return x; 
-    } 
-    return PyObject_Vectorcall(func, args, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames); 
-} 
- 
+
+static PyObject *
+trace_call_function(PyThreadState *tstate,
+                    PyObject *func,
+                    PyObject **args, Py_ssize_t nargs,
+                    PyObject *kwnames)
+{
+    PyObject *x;
+    if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) {
+        C_TRACE(x, PyObject_Vectorcall(func, args, nargs, kwnames));
+        return x;
+    }
+    else if (Py_IS_TYPE(func, &PyMethodDescr_Type) && nargs > 0) {
+        /* We need to create a temporary bound method as argument
+           for profiling.
+
+           If nargs == 0, then this cannot work because we have no
+           "self". In any case, the call itself would raise
+           TypeError (foo needs an argument), so we just skip
+           profiling. */
+        PyObject *self = args[0];
+        func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self));
+        if (func == NULL) {
+            return NULL;
+        }
+        C_TRACE(x, PyObject_Vectorcall(func,
+                                        args+1, nargs-1,
+                                        kwnames));
+        Py_DECREF(func);
+        return x;
+    }
+    return PyObject_Vectorcall(func, args, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
+}
+
 /* Issue #29227: Inline call_function() into _PyEval_EvalFrameDefault()
    to reduce the stack consumption. */
 Py_LOCAL_INLINE(PyObject *) _Py_HOT_FUNCTION
-call_function(PyThreadState *tstate, PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames) 
+call_function(PyThreadState *tstate, PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
 {
     PyObject **pfunc = (*pp_stack) - oparg - 1;
     PyObject *func = *pfunc;
@@ -5070,14 +5070,14 @@ call_function(PyThreadState *tstate, PyObject ***pp_stack, Py_ssize_t oparg, PyO
     Py_ssize_t nargs = oparg - nkwargs;
     PyObject **stack = (*pp_stack) - nargs - nkwargs;
 
-    if (tstate->use_tracing) { 
-        x = trace_call_function(tstate, func, stack, nargs, kwnames); 
+    if (tstate->use_tracing) {
+        x = trace_call_function(tstate, func, stack, nargs, kwnames);
     }
     else {
-        x = PyObject_Vectorcall(func, stack, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames); 
+        x = PyObject_Vectorcall(func, stack, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
     }
 
-    assert((x != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); 
+    assert((x != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
 
     /* Clear the stack of the function object. */
     while ((*pp_stack) > pfunc) {
@@ -5089,40 +5089,40 @@ call_function(PyThreadState *tstate, PyObject ***pp_stack, Py_ssize_t oparg, PyO
 }
 
 static PyObject *
-do_call_core(PyThreadState *tstate, PyObject *func, PyObject *callargs, PyObject *kwdict) 
+do_call_core(PyThreadState *tstate, PyObject *func, PyObject *callargs, PyObject *kwdict)
 {
-    PyObject *result; 
- 
-    if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) { 
-        C_TRACE(result, PyObject_Call(func, callargs, kwdict)); 
+    PyObject *result;
+
+    if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) {
+        C_TRACE(result, PyObject_Call(func, callargs, kwdict));
         return result;
     }
-    else if (Py_IS_TYPE(func, &PyMethodDescr_Type)) { 
-        Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); 
-        if (nargs > 0 && tstate->use_tracing) { 
-            /* We need to create a temporary bound method as argument 
-               for profiling. 
- 
-               If nargs == 0, then this cannot work because we have no 
-               "self". In any case, the call itself would raise 
-               TypeError (foo needs an argument), so we just skip 
-               profiling. */ 
-            PyObject *self = PyTuple_GET_ITEM(callargs, 0); 
-            func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self)); 
-            if (func == NULL) { 
-                return NULL; 
-            } 
- 
-            C_TRACE(result, _PyObject_FastCallDictTstate( 
-                                    tstate, func, 
-                                    &_PyTuple_ITEMS(callargs)[1], 
-                                    nargs - 1, 
-                                    kwdict)); 
-            Py_DECREF(func); 
-            return result; 
-        } 
-    }
-    return PyObject_Call(func, callargs, kwdict); 
+    else if (Py_IS_TYPE(func, &PyMethodDescr_Type)) {
+        Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
+        if (nargs > 0 && tstate->use_tracing) {
+            /* We need to create a temporary bound method as argument
+               for profiling.
+
+               If nargs == 0, then this cannot work because we have no
+               "self". In any case, the call itself would raise
+               TypeError (foo needs an argument), so we just skip
+               profiling. */
+            PyObject *self = PyTuple_GET_ITEM(callargs, 0);
+            func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self));
+            if (func == NULL) {
+                return NULL;
+            }
+
+            C_TRACE(result, _PyObject_FastCallDictTstate(
+                                    tstate, func,
+                                    &_PyTuple_ITEMS(callargs)[1],
+                                    nargs - 1,
+                                    kwdict));
+            Py_DECREF(func);
+            return result;
+        }
+    }
+    return PyObject_Call(func, callargs, kwdict);
 }
 
 /* Extract a slice index from a PyLong or an object with the
@@ -5134,18 +5134,18 @@ do_call_core(PyThreadState *tstate, PyObject *func, PyObject *callargs, PyObject
 int
 _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
+    PyThreadState *tstate = _PyThreadState_GET();
     if (v != Py_None) {
         Py_ssize_t x;
-        if (_PyIndex_Check(v)) { 
+        if (_PyIndex_Check(v)) {
             x = PyNumber_AsSsize_t(v, NULL);
-            if (x == -1 && _PyErr_Occurred(tstate)) 
+            if (x == -1 && _PyErr_Occurred(tstate))
                 return 0;
         }
         else {
-            _PyErr_SetString(tstate, PyExc_TypeError, 
-                             "slice indices must be integers or " 
-                             "None or have an __index__ method"); 
+            _PyErr_SetString(tstate, PyExc_TypeError,
+                             "slice indices must be integers or "
+                             "None or have an __index__ method");
             return 0;
         }
         *pi = x;
@@ -5156,17 +5156,17 @@ _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
 int
 _PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
 {
-    PyThreadState *tstate = _PyThreadState_GET(); 
+    PyThreadState *tstate = _PyThreadState_GET();
     Py_ssize_t x;
-    if (_PyIndex_Check(v)) { 
+    if (_PyIndex_Check(v)) {
         x = PyNumber_AsSsize_t(v, NULL);
-        if (x == -1 && _PyErr_Occurred(tstate)) 
+        if (x == -1 && _PyErr_Occurred(tstate))
             return 0;
     }
     else {
-        _PyErr_SetString(tstate, PyExc_TypeError, 
-                         "slice indices must be integers or " 
-                         "have an __index__ method"); 
+        _PyErr_SetString(tstate, PyExc_TypeError,
+                         "slice indices must be integers or "
+                         "have an __index__ method");
         return 0;
     }
     *pi = x;
@@ -5174,25 +5174,25 @@ _PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
 }
 
 static PyObject *
-import_name(PyThreadState *tstate, PyFrameObject *f, 
-            PyObject *name, PyObject *fromlist, PyObject *level) 
+import_name(PyThreadState *tstate, PyFrameObject *f,
+            PyObject *name, PyObject *fromlist, PyObject *level)
 {
     _Py_IDENTIFIER(__import__);
     PyObject *import_func, *res;
     PyObject* stack[5];
 
-    import_func = _PyDict_GetItemIdWithError(f->f_builtins, &PyId___import__); 
+    import_func = _PyDict_GetItemIdWithError(f->f_builtins, &PyId___import__);
     if (import_func == NULL) {
-        if (!_PyErr_Occurred(tstate)) { 
-            _PyErr_SetString(tstate, PyExc_ImportError, "__import__ not found"); 
-        } 
+        if (!_PyErr_Occurred(tstate)) {
+            _PyErr_SetString(tstate, PyExc_ImportError, "__import__ not found");
+        }
         return NULL;
     }
 
     /* Fast path for not overloaded __import__. */
-    if (import_func == tstate->interp->import_func) { 
+    if (import_func == tstate->interp->import_func) {
         int ilevel = _PyLong_AsInt(level);
-        if (ilevel == -1 && _PyErr_Occurred(tstate)) { 
+        if (ilevel == -1 && _PyErr_Occurred(tstate)) {
             return NULL;
         }
         res = PyImport_ImportModuleLevelObject(
@@ -5217,7 +5217,7 @@ import_name(PyThreadState *tstate, PyFrameObject *f,
 }
 
 static PyObject *
-import_from(PyThreadState *tstate, PyObject *v, PyObject *name) 
+import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
 {
     PyObject *x;
     PyObject *fullmodname, *pkgname, *pkgpath, *pkgname_or_unknown, *errmsg;
@@ -5243,7 +5243,7 @@ import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
     }
     x = PyImport_GetModule(fullmodname);
     Py_DECREF(fullmodname);
-    if (x == NULL && !_PyErr_Occurred(tstate)) { 
+    if (x == NULL && !_PyErr_Occurred(tstate)) {
         goto error;
     }
     Py_DECREF(pkgname);
@@ -5261,26 +5261,26 @@ import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
     }
 
     if (pkgpath == NULL || !PyUnicode_Check(pkgpath)) {
-        _PyErr_Clear(tstate); 
+        _PyErr_Clear(tstate);
         errmsg = PyUnicode_FromFormat(
             "cannot import name %R from %R (unknown location)",
             name, pkgname_or_unknown
         );
-        /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */ 
+        /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
         PyErr_SetImportError(errmsg, pkgname, NULL);
     }
     else {
-        _Py_IDENTIFIER(__spec__); 
-        PyObject *spec = _PyObject_GetAttrId(v, &PyId___spec__); 
-        const char *fmt = 
-            _PyModuleSpec_IsInitializing(spec) ? 
-            "cannot import name %R from partially initialized module %R " 
-            "(most likely due to a circular import) (%S)" : 
-            "cannot import name %R from %R (%S)"; 
-        Py_XDECREF(spec); 
- 
-        errmsg = PyUnicode_FromFormat(fmt, name, pkgname_or_unknown, pkgpath); 
-        /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */ 
+        _Py_IDENTIFIER(__spec__);
+        PyObject *spec = _PyObject_GetAttrId(v, &PyId___spec__);
+        const char *fmt =
+            _PyModuleSpec_IsInitializing(spec) ?
+            "cannot import name %R from partially initialized module %R "
+            "(most likely due to a circular import) (%S)" :
+            "cannot import name %R from %R (%S)";
+        Py_XDECREF(spec);
+
+        errmsg = PyUnicode_FromFormat(fmt, name, pkgname_or_unknown, pkgpath);
+        /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
         PyErr_SetImportError(errmsg, pkgname, pkgpath);
     }
 
@@ -5291,7 +5291,7 @@ import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
 }
 
 static int
-import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v) 
+import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
 {
     _Py_IDENTIFIER(__all__);
     _Py_IDENTIFIER(__dict__);
@@ -5307,7 +5307,7 @@ import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
             return -1;
         }
         if (dict == NULL) {
-            _PyErr_SetString(tstate, PyExc_ImportError, 
+            _PyErr_SetString(tstate, PyExc_ImportError,
                     "from-import-* object has no __dict__ and no __all__");
             return -1;
         }
@@ -5321,40 +5321,40 @@ import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
     for (pos = 0, err = 0; ; pos++) {
         name = PySequence_GetItem(all, pos);
         if (name == NULL) {
-            if (!_PyErr_ExceptionMatches(tstate, PyExc_IndexError)) { 
+            if (!_PyErr_ExceptionMatches(tstate, PyExc_IndexError)) {
                 err = -1;
-            } 
-            else { 
-                _PyErr_Clear(tstate); 
-            } 
+            }
+            else {
+                _PyErr_Clear(tstate);
+            }
             break;
         }
-        if (!PyUnicode_Check(name)) { 
-            PyObject *modname = _PyObject_GetAttrId(v, &PyId___name__); 
-            if (modname == NULL) { 
-                Py_DECREF(name); 
-                err = -1; 
-                break; 
-            } 
-            if (!PyUnicode_Check(modname)) { 
-                _PyErr_Format(tstate, PyExc_TypeError, 
-                              "module __name__ must be a string, not %.100s", 
-                              Py_TYPE(modname)->tp_name); 
-            } 
-            else { 
-                _PyErr_Format(tstate, PyExc_TypeError, 
-                              "%s in %U.%s must be str, not %.100s", 
-                              skip_leading_underscores ? "Key" : "Item", 
-                              modname, 
-                              skip_leading_underscores ? "__dict__" : "__all__", 
-                              Py_TYPE(name)->tp_name); 
-            } 
-            Py_DECREF(modname); 
-            Py_DECREF(name); 
-            err = -1; 
-            break; 
-        } 
-        if (skip_leading_underscores) { 
+        if (!PyUnicode_Check(name)) {
+            PyObject *modname = _PyObject_GetAttrId(v, &PyId___name__);
+            if (modname == NULL) {
+                Py_DECREF(name);
+                err = -1;
+                break;
+            }
+            if (!PyUnicode_Check(modname)) {
+                _PyErr_Format(tstate, PyExc_TypeError,
+                              "module __name__ must be a string, not %.100s",
+                              Py_TYPE(modname)->tp_name);
+            }
+            else {
+                _PyErr_Format(tstate, PyExc_TypeError,
+                              "%s in %U.%s must be str, not %.100s",
+                              skip_leading_underscores ? "Key" : "Item",
+                              modname,
+                              skip_leading_underscores ? "__dict__" : "__all__",
+                              Py_TYPE(name)->tp_name);
+            }
+            Py_DECREF(modname);
+            Py_DECREF(name);
+            err = -1;
+            break;
+        }
+        if (skip_leading_underscores) {
             if (PyUnicode_READY(name) == -1) {
                 Py_DECREF(name);
                 err = -1;
@@ -5382,72 +5382,72 @@ import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
 }
 
 static int
-check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args) 
+check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args)
 {
-    if (Py_TYPE(args)->tp_iter == NULL && !PySequence_Check(args)) { 
-        /* check_args_iterable() may be called with a live exception: 
-         * clear it to prevent calling _PyObject_FunctionStr() with an 
-         * exception set. */ 
-        _PyErr_Clear(tstate); 
-        PyObject *funcstr = _PyObject_FunctionStr(func); 
-        if (funcstr != NULL) { 
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "%U argument after * must be an iterable, not %.200s", 
-                          funcstr, Py_TYPE(args)->tp_name); 
-            Py_DECREF(funcstr); 
-        } 
+    if (Py_TYPE(args)->tp_iter == NULL && !PySequence_Check(args)) {
+        /* check_args_iterable() may be called with a live exception:
+         * clear it to prevent calling _PyObject_FunctionStr() with an
+         * exception set. */
+        _PyErr_Clear(tstate);
+        PyObject *funcstr = _PyObject_FunctionStr(func);
+        if (funcstr != NULL) {
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "%U argument after * must be an iterable, not %.200s",
+                          funcstr, Py_TYPE(args)->tp_name);
+            Py_DECREF(funcstr);
+        }
         return -1;
     }
     return 0;
 }
 
 static void
-format_kwargs_error(PyThreadState *tstate, PyObject *func, PyObject *kwargs) 
+format_kwargs_error(PyThreadState *tstate, PyObject *func, PyObject *kwargs)
 {
-    /* _PyDict_MergeEx raises attribute 
-     * error (percolated from an attempt 
-     * to get 'keys' attribute) instead of 
-     * a type error if its second argument 
-     * is not a mapping. 
-     */ 
-    if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) { 
-        _PyErr_Clear(tstate); 
-        PyObject *funcstr = _PyObject_FunctionStr(func); 
-        if (funcstr != NULL) { 
-            _PyErr_Format( 
-                tstate, PyExc_TypeError, 
-                "%U argument after ** must be a mapping, not %.200s", 
-                funcstr, Py_TYPE(kwargs)->tp_name); 
-            Py_DECREF(funcstr); 
-        } 
-    } 
-    else if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) { 
-        PyObject *exc, *val, *tb; 
-        _PyErr_Fetch(tstate, &exc, &val, &tb); 
-        if (val && PyTuple_Check(val) && PyTuple_GET_SIZE(val) == 1) { 
-            _PyErr_Clear(tstate); 
-            PyObject *funcstr = _PyObject_FunctionStr(func); 
-            if (funcstr != NULL) { 
-                PyObject *key = PyTuple_GET_ITEM(val, 0); 
-                _PyErr_Format( 
-                    tstate, PyExc_TypeError, 
-                    "%U got multiple values for keyword argument '%S'", 
-                    funcstr, key); 
-                Py_DECREF(funcstr); 
-            } 
-            Py_XDECREF(exc); 
-            Py_XDECREF(val); 
-            Py_XDECREF(tb); 
-        } 
-        else { 
-            _PyErr_Restore(tstate, exc, val, tb); 
-        } 
-    } 
+    /* _PyDict_MergeEx raises attribute
+     * error (percolated from an attempt
+     * to get 'keys' attribute) instead of
+     * a type error if its second argument
+     * is not a mapping.
+     */
+    if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
+        _PyErr_Clear(tstate);
+        PyObject *funcstr = _PyObject_FunctionStr(func);
+        if (funcstr != NULL) {
+            _PyErr_Format(
+                tstate, PyExc_TypeError,
+                "%U argument after ** must be a mapping, not %.200s",
+                funcstr, Py_TYPE(kwargs)->tp_name);
+            Py_DECREF(funcstr);
+        }
+    }
+    else if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
+        PyObject *exc, *val, *tb;
+        _PyErr_Fetch(tstate, &exc, &val, &tb);
+        if (val && PyTuple_Check(val) && PyTuple_GET_SIZE(val) == 1) {
+            _PyErr_Clear(tstate);
+            PyObject *funcstr = _PyObject_FunctionStr(func);
+            if (funcstr != NULL) {
+                PyObject *key = PyTuple_GET_ITEM(val, 0);
+                _PyErr_Format(
+                    tstate, PyExc_TypeError,
+                    "%U got multiple values for keyword argument '%S'",
+                    funcstr, key);
+                Py_DECREF(funcstr);
+            }
+            Py_XDECREF(exc);
+            Py_XDECREF(val);
+            Py_XDECREF(tb);
+        }
+        else {
+            _PyErr_Restore(tstate, exc, val, tb);
+        }
+    }
 }
 
 static void
-format_exc_check_arg(PyThreadState *tstate, PyObject *exc, 
-                     const char *format_str, PyObject *obj) 
+format_exc_check_arg(PyThreadState *tstate, PyObject *exc,
+                     const char *format_str, PyObject *obj)
 {
     const char *obj_str;
 
@@ -5458,52 +5458,52 @@ format_exc_check_arg(PyThreadState *tstate, PyObject *exc,
     if (!obj_str)
         return;
 
-    _PyErr_Format(tstate, exc, format_str, obj_str); 
+    _PyErr_Format(tstate, exc, format_str, obj_str);
 }
 
 static void
-format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg) 
+format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg)
 {
     PyObject *name;
     /* Don't stomp existing exception */
-    if (_PyErr_Occurred(tstate)) 
+    if (_PyErr_Occurred(tstate))
         return;
     if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
         name = PyTuple_GET_ITEM(co->co_cellvars,
                                 oparg);
-        format_exc_check_arg(tstate, 
+        format_exc_check_arg(tstate,
             PyExc_UnboundLocalError,
             UNBOUNDLOCAL_ERROR_MSG,
             name);
     } else {
         name = PyTuple_GET_ITEM(co->co_freevars, oparg -
                                 PyTuple_GET_SIZE(co->co_cellvars));
-        format_exc_check_arg(tstate, PyExc_NameError, 
+        format_exc_check_arg(tstate, PyExc_NameError,
                              UNBOUNDFREE_ERROR_MSG, name);
     }
 }
 
 static void
-format_awaitable_error(PyThreadState *tstate, PyTypeObject *type, int prevprevopcode, int prevopcode) 
+format_awaitable_error(PyThreadState *tstate, PyTypeObject *type, int prevprevopcode, int prevopcode)
 {
     if (type->tp_as_async == NULL || type->tp_as_async->am_await == NULL) {
         if (prevopcode == BEFORE_ASYNC_WITH) {
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "'async with' received an object from __aenter__ " 
-                          "that does not implement __await__: %.100s", 
-                          type->tp_name); 
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "'async with' received an object from __aenter__ "
+                          "that does not implement __await__: %.100s",
+                          type->tp_name);
         }
-        else if (prevopcode == WITH_EXCEPT_START || (prevopcode == CALL_FUNCTION && prevprevopcode == DUP_TOP)) { 
-            _PyErr_Format(tstate, PyExc_TypeError, 
-                          "'async with' received an object from __aexit__ " 
-                          "that does not implement __await__: %.100s", 
-                          type->tp_name); 
+        else if (prevopcode == WITH_EXCEPT_START || (prevopcode == CALL_FUNCTION && prevprevopcode == DUP_TOP)) {
+            _PyErr_Format(tstate, PyExc_TypeError,
+                          "'async with' received an object from __aexit__ "
+                          "that does not implement __await__: %.100s",
+                          type->tp_name);
         }
     }
 }
 
 static PyObject *
-unicode_concatenate(PyThreadState *tstate, PyObject *v, PyObject *w, 
+unicode_concatenate(PyThreadState *tstate, PyObject *v, PyObject *w,
                     PyFrameObject *f, const _Py_CODEUNIT *next_instr)
 {
     PyObject *res;
@@ -5540,13 +5540,13 @@ unicode_concatenate(PyThreadState *tstate, PyObject *v, PyObject *w,
             PyObject *names = f->f_code->co_names;
             PyObject *name = GETITEM(names, oparg);
             PyObject *locals = f->f_locals;
-            if (locals && PyDict_CheckExact(locals)) { 
-                PyObject *w = PyDict_GetItemWithError(locals, name); 
-                if ((w == v && PyDict_DelItem(locals, name) != 0) || 
-                    (w == NULL && _PyErr_Occurred(tstate))) 
-                { 
-                    Py_DECREF(v); 
-                    return NULL; 
+            if (locals && PyDict_CheckExact(locals)) {
+                PyObject *w = PyDict_GetItemWithError(locals, name);
+                if ((w == v && PyDict_DelItem(locals, name) != 0) ||
+                    (w == NULL && _PyErr_Occurred(tstate)))
+                {
+                    Py_DECREF(v);
+                    return NULL;
                 }
             }
             break;
@@ -5605,7 +5605,7 @@ _Py_GetDXProfile(PyObject *self, PyObject *args)
 Py_ssize_t
 _PyEval_RequestCodeExtraIndex(freefunc free)
 {
-    PyInterpreterState *interp = _PyInterpreterState_GET(); 
+    PyInterpreterState *interp = _PyInterpreterState_GET();
     Py_ssize_t new_index;
 
     if (interp->co_extra_user_count == MAX_CO_EXTRA_USERS - 1) {
@@ -5623,10 +5623,10 @@ dtrace_function_entry(PyFrameObject *f)
     const char *funcname;
     int lineno;
 
-    PyCodeObject *code = f->f_code; 
-    filename = PyUnicode_AsUTF8(code->co_filename); 
-    funcname = PyUnicode_AsUTF8(code->co_name); 
-    lineno = PyCode_Addr2Line(code, f->f_lasti); 
+    PyCodeObject *code = f->f_code;
+    filename = PyUnicode_AsUTF8(code->co_filename);
+    funcname = PyUnicode_AsUTF8(code->co_name);
+    lineno = PyCode_Addr2Line(code, f->f_lasti);
 
     PyDTrace_FUNCTION_ENTRY(filename, funcname, lineno);
 }
@@ -5638,10 +5638,10 @@ dtrace_function_return(PyFrameObject *f)
     const char *funcname;
     int lineno;
 
-    PyCodeObject *code = f->f_code; 
-    filename = PyUnicode_AsUTF8(code->co_filename); 
-    funcname = PyUnicode_AsUTF8(code->co_name); 
-    lineno = PyCode_Addr2Line(code, f->f_lasti); 
+    PyCodeObject *code = f->f_code;
+    filename = PyUnicode_AsUTF8(code->co_filename);
+    funcname = PyUnicode_AsUTF8(code->co_name);
+    lineno = PyCode_Addr2Line(code, f->f_lasti);
 
     PyDTrace_FUNCTION_RETURN(filename, funcname, lineno);
 }
@@ -5679,21 +5679,21 @@ maybe_dtrace_line(PyFrameObject *frame,
     }
     *instr_prev = frame->f_lasti;
 }
- 
- 
-/* Implement Py_EnterRecursiveCall() and Py_LeaveRecursiveCall() as functions 
-   for the limited API. */ 
- 
-#undef Py_EnterRecursiveCall 
- 
-int Py_EnterRecursiveCall(const char *where) 
-{ 
-    return _Py_EnterRecursiveCall_inline(where); 
-} 
- 
-#undef Py_LeaveRecursiveCall 
- 
-void Py_LeaveRecursiveCall(void) 
-{ 
-    _Py_LeaveRecursiveCall_inline(); 
-} 
+
+
+/* Implement Py_EnterRecursiveCall() and Py_LeaveRecursiveCall() as functions
+   for the limited API. */
+
+#undef Py_EnterRecursiveCall
+
+int Py_EnterRecursiveCall(const char *where)
+{
+    return _Py_EnterRecursiveCall_inline(where);
+}
+
+#undef Py_LeaveRecursiveCall
+
+void Py_LeaveRecursiveCall(void)
+{
+    _Py_LeaveRecursiveCall_inline();
+}