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

1 files changed, 3811 insertions, 3811 deletions

diff --git a/contrib/tools/python3/src/Python/ceval.c b/contrib/tools/python3/src/Python/ceval.c
index 9a61f8a3c3..956f67ed42 100644
--- a/contrib/tools/python3/src/Python/ceval.c
+++ b/contrib/tools/python3/src/Python/ceval.c
@@ -1,15 +1,15 @@
-
-/* Execute compiled code */
-
-/* XXX TO DO:
-   XXX speed up searching for keywords by using a dictionary
-   XXX document it!
-   */
-
-/* enable more aggressive intra-module optimizations, where available */
-#define PY_LOCAL_AGGRESSIVE
-
-#include "Python.h"
+ 
+/* Execute compiled code */ 
+ 
+/* XXX TO DO: 
+   XXX speed up searching for keywords by using a dictionary 
+   XXX document it! 
+   */ 
+ 
+/* enable more aggressive intra-module optimizations, where available */ 
+#define PY_LOCAL_AGGRESSIVE 
+ 
+#include "Python.h" 
 #include "pycore_abstract.h"      // _PyIndex_Check()
 #include "pycore_call.h"
 #include "pycore_ceval.h"
@@ -22,55 +22,55 @@
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
 #include "pycore_sysmodule.h"
 #include "pycore_tupleobject.h"
-
-#include "code.h"
-#include "dictobject.h"
-#include "frameobject.h"
-#include "opcode.h"
-#include "pydtrace.h"
-#include "setobject.h"
-
-#include <ctype.h>
-
-#ifdef Py_DEBUG
-/* For debugging the interpreter: */
-#define LLTRACE  1      /* Low-level trace feature */
-#define CHECKEXC 1      /* Double-check exception checking */
-#endif
-
+ 
+#include "code.h" 
+#include "dictobject.h" 
+#include "frameobject.h" 
+#include "opcode.h" 
+#include "pydtrace.h" 
+#include "setobject.h" 
+ 
+#include <ctype.h> 
+ 
+#ifdef Py_DEBUG 
+/* For debugging the interpreter: */ 
+#define LLTRACE  1      /* Low-level trace feature */ 
+#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__);
-
-/* Forward declarations */
+ 
+/* 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);
-
-#ifdef LLTRACE
-static int lltrace;
+ 
+#ifdef LLTRACE 
+static int lltrace; 
 static int prtrace(PyThreadState *, PyObject *, const char *);
-#endif
-static int call_trace(Py_tracefunc, PyObject *,
-                      PyThreadState *, PyFrameObject *,
-                      int, PyObject *);
-static int call_trace_protected(Py_tracefunc, PyObject *,
-                                PyThreadState *, PyFrameObject *,
-                                int, PyObject *);
-static void call_exc_trace(Py_tracefunc, PyObject *,
-                           PyThreadState *, PyFrameObject *);
-static int maybe_call_line_trace(Py_tracefunc, PyObject *,
-                                 PyThreadState *, PyFrameObject *,
-                                 int *, int *, int *);
-static void maybe_dtrace_line(PyFrameObject *, int *, int *, int *);
-static void dtrace_function_entry(PyFrameObject *);
-static void dtrace_function_return(PyFrameObject *);
-
+#endif 
+static int call_trace(Py_tracefunc, PyObject *, 
+                      PyThreadState *, PyFrameObject *, 
+                      int, PyObject *); 
+static int call_trace_protected(Py_tracefunc, PyObject *, 
+                                PyThreadState *, PyFrameObject *, 
+                                int, PyObject *); 
+static void call_exc_trace(Py_tracefunc, PyObject *, 
+                           PyThreadState *, PyFrameObject *); 
+static int maybe_call_line_trace(Py_tracefunc, PyObject *, 
+                                 PyThreadState *, PyFrameObject *, 
+                                 int *, int *, int *); 
+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 *);
@@ -78,30 +78,30 @@ 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 *);
+                                      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);
-
-#define NAME_ERROR_MSG \
-    "name '%.200s' is not defined"
-#define UNBOUNDLOCAL_ERROR_MSG \
-    "local variable '%.200s' referenced before assignment"
-#define UNBOUNDFREE_ERROR_MSG \
-    "free variable '%.200s' referenced before assignment" \
-    " in enclosing scope"
-
-/* Dynamic execution profile */
-#ifdef DYNAMIC_EXECUTION_PROFILE
-#ifdef DXPAIRS
-static long dxpairs[257][256];
-#define dxp dxpairs[256]
-#else
-static long dxp[256];
-#endif
-#endif
-
+ 
+#define NAME_ERROR_MSG \ 
+    "name '%.200s' is not defined" 
+#define UNBOUNDLOCAL_ERROR_MSG \ 
+    "local variable '%.200s' referenced before assignment" 
+#define UNBOUNDFREE_ERROR_MSG \ 
+    "free variable '%.200s' referenced before assignment" \ 
+    " in enclosing scope" 
+ 
+/* Dynamic execution profile */ 
+#ifdef DYNAMIC_EXECUTION_PROFILE 
+#ifdef DXPAIRS 
+static long dxpairs[257][256]; 
+#define dxp dxpairs[256] 
+#else 
+static long dxp[256]; 
+#endif 
+#endif 
+ 
 /* per opcode cache */
 #ifdef Py_DEBUG
 // --with-pydebug is used to find memory leak.  opcache makes it harder.
@@ -112,7 +112,7 @@ static long dxp[256];
 #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;
@@ -138,9 +138,9 @@ is_tstate_valid(PyThreadState *tstate)
 #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. */
+/* 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,
@@ -154,8 +154,8 @@ COMPUTE_EVAL_BREAKER(PyInterpreterState *interp,
            && _Py_ThreadCanHandlePendingCalls())
         | ceval2->pending.async_exc);
 }
-
-
+ 
+ 
 static inline void
 SET_GIL_DROP_REQUEST(PyInterpreterState *interp)
 {
@@ -163,8 +163,8 @@ SET_GIL_DROP_REQUEST(PyInterpreterState *interp)
     _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)
 {
@@ -173,8 +173,8 @@ RESET_GIL_DROP_REQUEST(PyInterpreterState *interp)
     _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 0);
     COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
 }
-
-
+ 
+ 
 static inline void
 SIGNAL_PENDING_CALLS(PyInterpreterState *interp)
 {
@@ -183,8 +183,8 @@ SIGNAL_PENDING_CALLS(PyInterpreterState *interp)
     _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 1);
     COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
 }
-
-
+ 
+ 
 static inline void
 UNSIGNAL_PENDING_CALLS(PyInterpreterState *interp)
 {
@@ -240,11 +240,11 @@ UNSIGNAL_ASYNC_EXC(PyInterpreterState *interp)
 }
 
 
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#include "ceval_gil.h"
-
+#ifdef HAVE_ERRNO_H 
+#include <errno.h> 
+#endif 
+#include "ceval_gil.h" 
+ 
 void _Py_NO_RETURN
 _Py_FatalError_TstateNULL(const char *func)
 {
@@ -255,22 +255,22 @@ _Py_FatalError_TstateNULL(const char *func)
 }
 
 
-int
+int 
 _PyEval_ThreadsInitialized(_PyRuntimeState *runtime)
 {
     return gil_created(&runtime->ceval.gil);
 }
 
 int
-PyEval_ThreadsInitialized(void)
-{
+PyEval_ThreadsInitialized(void) 
+{ 
     _PyRuntimeState *runtime = &_PyRuntime;
     return _PyEval_ThreadsInitialized(runtime);
-}
-
+} 
+ 
 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
@@ -288,11 +288,11 @@ _PyEval_InitGIL(PyThreadState *tstate)
 
     assert(gil_created(gil));
     return _PyStatus_OK();
-}
-
-void
+} 
+ 
+void 
 _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
@@ -304,20 +304,20 @@ _PyEval_FiniGIL(PyThreadState *tstate)
     if (!gil_created(gil)) {
         /* First Py_InitializeFromConfig() call: the GIL doesn't exist
            yet: do nothing. */
-        return;
+        return; 
     }
 
     destroy_gil(gil);
     assert(!gil_created(gil));
-}
-
+} 
+ 
 void
 PyEval_InitThreads(void)
 {
     /* Do nothing: kept for backward compatibility */
 }
 
-void
+void 
 _PyEval_Fini(void)
 {
 #if OPCACHE_STATS
@@ -347,29 +347,29 @@ _PyEval_Fini(void)
 }
 
 void
-PyEval_AcquireLock(void)
-{
+PyEval_AcquireLock(void) 
+{ 
     _PyRuntimeState *runtime = &_PyRuntime;
     PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
     _Py_EnsureTstateNotNULL(tstate);
 
     take_gil(tstate);
-}
-
-void
-PyEval_ReleaseLock(void)
-{
+} 
+ 
+void 
+PyEval_ReleaseLock(void) 
+{ 
     _PyRuntimeState *runtime = &_PyRuntime;
     PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
-    /* This function must succeed when the current thread state is NULL.
+    /* 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);
-}
-
-void
+} 
+ 
+void 
 _PyEval_ReleaseLock(PyThreadState *tstate)
 {
     struct _ceval_runtime_state *ceval = &tstate->interp->runtime->ceval;
@@ -378,8 +378,8 @@ _PyEval_ReleaseLock(PyThreadState *tstate)
 }
 
 void
-PyEval_AcquireThread(PyThreadState *tstate)
-{
+PyEval_AcquireThread(PyThreadState *tstate) 
+{ 
     _Py_EnsureTstateNotNULL(tstate);
 
     take_gil(tstate);
@@ -388,11 +388,11 @@ PyEval_AcquireThread(PyThreadState *tstate)
     if (_PyThreadState_Swap(gilstate, tstate) != NULL) {
         Py_FatalError("non-NULL old thread state");
     }
-}
-
-void
-PyEval_ReleaseThread(PyThreadState *tstate)
-{
+} 
+ 
+void 
+PyEval_ReleaseThread(PyThreadState *tstate) 
+{ 
     assert(is_tstate_valid(tstate));
 
     _PyRuntimeState *runtime = tstate->interp->runtime;
@@ -403,26 +403,26 @@ PyEval_ReleaseThread(PyThreadState *tstate)
     struct _ceval_runtime_state *ceval = &runtime->ceval;
     struct _ceval_state *ceval2 = &tstate->interp->ceval;
     drop_gil(ceval, ceval2, tstate);
-}
-
+} 
+ 
 #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
+/* 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)
-{
+{ 
     PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
     _Py_EnsureTstateNotNULL(tstate);
 
     struct _gil_runtime_state *gil = &runtime->ceval.gil;
     if (!gil_created(gil)) {
-        return;
+        return; 
     }
     recreate_gil(gil);
-
+ 
     take_gil(tstate);
 
     struct _pending_calls *pending = &tstate->interp->ceval.pending;
@@ -430,24 +430,24 @@ _PyEval_ReInitThreads(_PyRuntimeState *runtime)
         Py_FatalError("Can't initialize threads for pending calls");
     }
 
-    /* Destroy all threads except the current one */
+    /* Destroy all threads except the current one */ 
     _PyThreadState_DeleteExcept(runtime, tstate);
-}
+} 
 #endif
-
-/* This function is used to signal that async exceptions are waiting to be
+ 
+/* This function is used to signal that async exceptions are waiting to be 
    raised. */
-
-void
+ 
+void 
 _PyEval_SignalAsyncExc(PyThreadState *tstate)
-{
+{ 
     assert(is_tstate_valid(tstate));
     SIGNAL_ASYNC_EXC(tstate->interp);
-}
-
-PyThreadState *
-PyEval_SaveThread(void)
-{
+} 
+ 
+PyThreadState * 
+PyEval_SaveThread(void) 
+{ 
     _PyRuntimeState *runtime = &_PyRuntime;
     PyThreadState *tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);
     _Py_EnsureTstateNotNULL(tstate);
@@ -456,46 +456,46 @@ PyEval_SaveThread(void)
     struct _ceval_state *ceval2 = &tstate->interp->ceval;
     assert(gil_created(&ceval->gil));
     drop_gil(ceval, ceval2, tstate);
-    return tstate;
-}
-
-void
-PyEval_RestoreThread(PyThreadState *tstate)
-{
+    return tstate; 
+} 
+ 
+void 
+PyEval_RestoreThread(PyThreadState *tstate) 
+{ 
     _Py_EnsureTstateNotNULL(tstate);
 
     take_gil(tstate);
-
+ 
     struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;
     _PyThreadState_Swap(gilstate, tstate);
-}
-
-
-/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
-   signal handlers or Mac I/O completion routines) can schedule calls
-   to a function to be called synchronously.
-   The synchronous function is called with one void* argument.
-   It should return 0 for success or -1 for failure -- failure should
-   be accompanied by an exception.
-
-   If registry succeeds, the registry function returns 0; if it fails
-   (e.g. due to too many pending calls) it returns -1 (without setting
-   an exception condition).
-
-   Note that because registry may occur from within signal handlers,
-   or other asynchronous events, calling malloc() is unsafe!
-
-   Any thread can schedule pending calls, but only the main thread
-   will execute them.
-   There is no facility to schedule calls to a particular thread, but
-   that should be easy to change, should that ever be required.  In
-   that case, the static variables here should go into the python
-   threadstate.
-*/
-
-void
+} 
+ 
+ 
+/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX 
+   signal handlers or Mac I/O completion routines) can schedule calls 
+   to a function to be called synchronously. 
+   The synchronous function is called with one void* argument. 
+   It should return 0 for success or -1 for failure -- failure should 
+   be accompanied by an exception. 
+ 
+   If registry succeeds, the registry function returns 0; if it fails 
+   (e.g. due to too many pending calls) it returns -1 (without setting 
+   an exception condition). 
+ 
+   Note that because registry may occur from within signal handlers, 
+   or other asynchronous events, calling malloc() is unsafe! 
+ 
+   Any thread can schedule pending calls, but only the main thread 
+   will execute them. 
+   There is no facility to schedule calls to a particular thread, but 
+   that should be easy to change, should that ever be required.  In 
+   that case, the static variables here should go into the python 
+   threadstate. 
+*/ 
+ 
+void 
 _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
@@ -508,12 +508,12 @@ _PyEval_SignalReceived(PyInterpreterState *interp)
 #else
     int force = 0;
 #endif
-    /* bpo-30703: Function called when the C signal handler of Python gets a
+    /* bpo-30703: Function called when the C signal handler of Python gets a 
        signal. We cannot queue a callback using _PyEval_AddPendingCall() since
-       that function is not async-signal-safe. */
+       that function is not async-signal-safe. */ 
     SIGNAL_PENDING_SIGNALS(interp, force);
-}
-
+} 
+ 
 /* Push one item onto the queue while holding the lock. */
 static int
 _push_pending_call(struct _pending_calls *pending,
@@ -545,17 +545,17 @@ _pop_pending_call(struct _pending_calls *pending,
     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
+/* 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)
-{
+{ 
     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);
@@ -563,15 +563,15 @@ _PyEval_AddPendingCall(PyInterpreterState *interp,
     PyThread_acquire_lock(pending->lock, WAIT_LOCK);
     int result = _push_pending_call(pending, func, arg);
     PyThread_release_lock(pending->lock);
-
-    /* signal main loop */
+ 
+    /* signal main loop */ 
     SIGNAL_PENDING_CALLS(interp);
-    return result;
-}
-
-int
+    return result; 
+} 
+ 
+int 
 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.
@@ -599,7 +599,7 @@ Py_AddPendingCall(int (*func)(void *), void *arg)
     }
     return _PyEval_AddPendingCall(interp, func, arg);
 }
-
+ 
 static int
 handle_signals(PyThreadState *tstate)
 {
@@ -607,16 +607,16 @@ handle_signals(PyThreadState *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)
 {
@@ -624,51 +624,51 @@ make_pending_calls(PyThreadState *tstate)
 
     /* only execute pending calls on main thread */
     if (!_Py_ThreadCanHandlePendingCalls()) {
-        return 0;
-    }
+        return 0; 
+    } 
 
-    /* don't perform recursive pending calls */
+    /* don't perform recursive pending calls */ 
     static int busy = 0;
     if (busy) {
-        return 0;
+        return 0; 
     }
-    busy = 1;
+    busy = 1; 
 
-    /* unsignal before starting to call callbacks, so that any callback
-       added in-between re-signals */
+    /* unsignal before starting to call callbacks, so that any callback 
+       added in-between re-signals */ 
     UNSIGNAL_PENDING_CALLS(tstate->interp);
     int res = 0;
-
-    /* perform a bounded number of calls, in case of recursion */
+ 
+    /* 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;
-        void *arg = NULL;
-
-        /* pop one item off the queue while holding the lock */
+        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);
 
-        /* having released the lock, perform the callback */
+        /* having released the lock, perform the callback */ 
         if (func == NULL) {
-            break;
+            break; 
         }
         res = func(arg);
         if (res) {
-            goto error;
-        }
-    }
-
-    busy = 0;
+            goto error; 
+        } 
+    } 
+ 
+    busy = 0; 
     return res;
-
-error:
-    busy = 0;
+ 
+error: 
+    busy = 0; 
     SIGNAL_PENDING_CALLS(tstate->interp);
     return res;
-}
-
+} 
+ 
 void
 _Py_FinishPendingCalls(PyThreadState *tstate)
 {
@@ -713,22 +713,22 @@ Py_MakePendingCalls(void)
     return 0;
 }
 
-/* The interpreter's recursion limit */
-
-#ifndef Py_DEFAULT_RECURSION_LIMIT
-#define Py_DEFAULT_RECURSION_LIMIT 1000
-#endif
-
-int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
-
-void
+/* The interpreter's recursion limit */ 
+ 
+#ifndef Py_DEFAULT_RECURSION_LIMIT 
+#define Py_DEFAULT_RECURSION_LIMIT 1000 
+#endif 
+ 
+int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT; 
+ 
+void 
 _PyEval_InitRuntimeState(struct _ceval_runtime_state *ceval)
-{
-    _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
+{ 
+    _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT; 
     _gil_initialize(&ceval->gil);
-}
-
-int
+} 
+ 
+int 
 _PyEval_InitState(struct _ceval_state *ceval)
 {
     ceval->recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
@@ -755,53 +755,53 @@ _PyEval_FiniState(struct _ceval_state *ceval)
 }
 
 int
-Py_GetRecursionLimit(void)
-{
+Py_GetRecursionLimit(void) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     return tstate->interp->ceval.recursion_limit;
-}
-
-void
-Py_SetRecursionLimit(int new_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;
     }
-}
-
+} 
+ 
 /* 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
+   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)
-{
+{ 
     int recursion_limit = tstate->interp->ceval.recursion_limit;
-
-#ifdef USE_STACKCHECK
-    tstate->stackcheck_counter = 0;
-    if (PyOS_CheckStack()) {
-        --tstate->recursion_depth;
+ 
+#ifdef USE_STACKCHECK 
+    tstate->stackcheck_counter = 0; 
+    if (PyOS_CheckStack()) { 
+        --tstate->recursion_depth; 
         _PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");
-        return -1;
-    }
+        return -1; 
+    } 
     if (_Py_IsMainInterpreter(tstate)) {
         /* Needed for ABI backwards-compatibility (see bpo-31857) */
         _Py_CheckRecursionLimit = recursion_limit;
     }
-#endif
+#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) {
-            /* Overflowing while handling an overflow. Give up. */
-            Py_FatalError("Cannot recover from stack overflow.");
-        }
-    }
+            /* Overflowing while handling an overflow. Give up. */ 
+            Py_FatalError("Cannot recover from stack overflow."); 
+        } 
+    } 
     else {
         if (tstate->recursion_depth > recursion_limit) {
             tstate->overflowed++;
@@ -812,45 +812,45 @@ _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
             --tstate->recursion_depth;
             return -1;
         }
-    }
-    return 0;
-}
-
+    } 
+    return 0; 
+} 
+ 
 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)
-
-
-PyObject *
-PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
-{
-    return PyEval_EvalCodeEx(co,
-                      globals, locals,
-                      (PyObject **)NULL, 0,
-                      (PyObject **)NULL, 0,
-                      (PyObject **)NULL, 0,
-                      NULL, NULL);
-}
-
-
-/* Interpreter main loop */
-
-PyObject *
+ 
+ 
+PyObject * 
+PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals) 
+{ 
+    return PyEval_EvalCodeEx(co, 
+                      globals, locals, 
+                      (PyObject **)NULL, 0, 
+                      (PyObject **)NULL, 0, 
+                      (PyObject **)NULL, 0, 
+                      NULL, NULL); 
+} 
+ 
+ 
+/* Interpreter main loop */ 
+ 
+PyObject * 
 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)
-{
+} 
+ 
+PyObject * 
+PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     return _PyEval_EvalFrame(tstate, f, throwflag);
-}
-
+} 
+ 
 
 /* Handle signals, pending calls, GIL drop request
    and asynchronous exception */
@@ -916,128 +916,128 @@ eval_frame_handle_pending(PyThreadState *tstate)
     return 0;
 }
 
-PyObject* _Py_HOT_FUNCTION
+PyObject* _Py_HOT_FUNCTION 
 _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
-{
+{ 
     _Py_EnsureTstateNotNULL(tstate);
 
-#ifdef DXPAIRS
-    int lastopcode = 0;
-#endif
-    PyObject **stack_pointer;  /* Next free slot in value stack */
-    const _Py_CODEUNIT *next_instr;
-    int opcode;        /* Current opcode */
-    int oparg;         /* Current opcode argument, if any */
-    PyObject **fastlocals, **freevars;
-    PyObject *retval = NULL;            /* Return value */
+#ifdef DXPAIRS 
+    int lastopcode = 0; 
+#endif 
+    PyObject **stack_pointer;  /* Next free slot in value stack */ 
+    const _Py_CODEUNIT *next_instr; 
+    int opcode;        /* Current opcode */ 
+    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;
-    PyCodeObject *co;
-
-    /* when tracing we set things up so that
-
-           not (instr_lb <= current_bytecode_offset < instr_ub)
-
-       is true when the line being executed has changed.  The
-       initial values are such as to make this false the first
-       time it is tested. */
-    int instr_ub = -1, instr_lb = 0, instr_prev = -1;
-
-    const _Py_CODEUNIT *first_instr;
-    PyObject *names;
-    PyObject *consts;
+    PyCodeObject *co; 
+ 
+    /* when tracing we set things up so that 
+ 
+           not (instr_lb <= current_bytecode_offset < instr_ub) 
+ 
+       is true when the line being executed has changed.  The 
+       initial values are such as to make this false the first 
+       time it is tested. */ 
+    int instr_ub = -1, instr_lb = 0, instr_prev = -1; 
+ 
+    const _Py_CODEUNIT *first_instr; 
+    PyObject *names; 
+    PyObject *consts; 
     _PyOpcache *co_opcache;
-
-#ifdef LLTRACE
-    _Py_IDENTIFIER(__ltrace__);
-#endif
-
-/* Computed GOTOs, or
-       the-optimization-commonly-but-improperly-known-as-"threaded code"
-   using gcc's labels-as-values extension
-   (http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html).
-
-   The traditional bytecode evaluation loop uses a "switch" statement, which
-   decent compilers will optimize as a single indirect branch instruction
-   combined with a lookup table of jump addresses. However, since the
-   indirect jump instruction is shared by all opcodes, the CPU will have a
-   hard time making the right prediction for where to jump next (actually,
-   it will be always wrong except in the uncommon case of a sequence of
-   several identical opcodes).
-
-   "Threaded code" in contrast, uses an explicit jump table and an explicit
-   indirect jump instruction at the end of each opcode. Since the jump
-   instruction is at a different address for each opcode, the CPU will make a
-   separate prediction for each of these instructions, which is equivalent to
-   predicting the second opcode of each opcode pair. These predictions have
-   a much better chance to turn out valid, especially in small bytecode loops.
-
-   A mispredicted branch on a modern CPU flushes the whole pipeline and
-   can cost several CPU cycles (depending on the pipeline depth),
-   and potentially many more instructions (depending on the pipeline width).
-   A correctly predicted branch, however, is nearly free.
-
-   At the time of this writing, the "threaded code" version is up to 15-20%
-   faster than the normal "switch" version, depending on the compiler and the
-   CPU architecture.
-
-   We disable the optimization if DYNAMIC_EXECUTION_PROFILE is defined,
-   because it would render the measurements invalid.
-
-
-   NOTE: care must be taken that the compiler doesn't try to "optimize" the
-   indirect jumps by sharing them between all opcodes. Such optimizations
-   can be disabled on gcc by using the -fno-gcse flag (or possibly
-   -fno-crossjumping).
-*/
-
-#ifdef DYNAMIC_EXECUTION_PROFILE
-#undef USE_COMPUTED_GOTOS
-#define USE_COMPUTED_GOTOS 0
-#endif
-
-#ifdef HAVE_COMPUTED_GOTOS
-    #ifndef USE_COMPUTED_GOTOS
-    #define USE_COMPUTED_GOTOS 1
-    #endif
-#else
-    #if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS
-    #error "Computed gotos are not supported on this compiler."
-    #endif
-    #undef USE_COMPUTED_GOTOS
-    #define USE_COMPUTED_GOTOS 0
-#endif
-
-#if USE_COMPUTED_GOTOS
-/* Import the static jump table */
-#include "opcode_targets.h"
-
-#define TARGET(op) \
+ 
+#ifdef LLTRACE 
+    _Py_IDENTIFIER(__ltrace__); 
+#endif 
+ 
+/* Computed GOTOs, or 
+       the-optimization-commonly-but-improperly-known-as-"threaded code" 
+   using gcc's labels-as-values extension 
+   (http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html). 
+ 
+   The traditional bytecode evaluation loop uses a "switch" statement, which 
+   decent compilers will optimize as a single indirect branch instruction 
+   combined with a lookup table of jump addresses. However, since the 
+   indirect jump instruction is shared by all opcodes, the CPU will have a 
+   hard time making the right prediction for where to jump next (actually, 
+   it will be always wrong except in the uncommon case of a sequence of 
+   several identical opcodes). 
+ 
+   "Threaded code" in contrast, uses an explicit jump table and an explicit 
+   indirect jump instruction at the end of each opcode. Since the jump 
+   instruction is at a different address for each opcode, the CPU will make a 
+   separate prediction for each of these instructions, which is equivalent to 
+   predicting the second opcode of each opcode pair. These predictions have 
+   a much better chance to turn out valid, especially in small bytecode loops. 
+ 
+   A mispredicted branch on a modern CPU flushes the whole pipeline and 
+   can cost several CPU cycles (depending on the pipeline depth), 
+   and potentially many more instructions (depending on the pipeline width). 
+   A correctly predicted branch, however, is nearly free. 
+ 
+   At the time of this writing, the "threaded code" version is up to 15-20% 
+   faster than the normal "switch" version, depending on the compiler and the 
+   CPU architecture. 
+ 
+   We disable the optimization if DYNAMIC_EXECUTION_PROFILE is defined, 
+   because it would render the measurements invalid. 
+ 
+ 
+   NOTE: care must be taken that the compiler doesn't try to "optimize" the 
+   indirect jumps by sharing them between all opcodes. Such optimizations 
+   can be disabled on gcc by using the -fno-gcse flag (or possibly 
+   -fno-crossjumping). 
+*/ 
+ 
+#ifdef DYNAMIC_EXECUTION_PROFILE 
+#undef USE_COMPUTED_GOTOS 
+#define USE_COMPUTED_GOTOS 0 
+#endif 
+ 
+#ifdef HAVE_COMPUTED_GOTOS 
+    #ifndef USE_COMPUTED_GOTOS 
+    #define USE_COMPUTED_GOTOS 1 
+    #endif 
+#else 
+    #if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS 
+    #error "Computed gotos are not supported on this compiler." 
+    #endif 
+    #undef USE_COMPUTED_GOTOS 
+    #define USE_COMPUTED_GOTOS 0 
+#endif 
+ 
+#if USE_COMPUTED_GOTOS 
+/* Import the static jump table */ 
+#include "opcode_targets.h" 
+ 
+#define TARGET(op) \ 
     op: \
     TARGET_##op
-
-#ifdef LLTRACE
-#define FAST_DISPATCH() \
-    { \
+ 
+#ifdef LLTRACE 
+#define FAST_DISPATCH() \ 
+    { \ 
         if (!lltrace && !_Py_TracingPossible(ceval2) && !PyDTrace_LINE_ENABLED()) { \
-            f->f_lasti = INSTR_OFFSET(); \
-            NEXTOPARG(); \
-            goto *opcode_targets[opcode]; \
-        } \
-        goto fast_next_opcode; \
-    }
-#else
-#define FAST_DISPATCH() \
-    { \
+            f->f_lasti = INSTR_OFFSET(); \ 
+            NEXTOPARG(); \ 
+            goto *opcode_targets[opcode]; \ 
+        } \ 
+        goto fast_next_opcode; \ 
+    } 
+#else 
+#define FAST_DISPATCH() \ 
+    { \ 
         if (!_Py_TracingPossible(ceval2) && !PyDTrace_LINE_ENABLED()) { \
-            f->f_lasti = INSTR_OFFSET(); \
-            NEXTOPARG(); \
-            goto *opcode_targets[opcode]; \
-        } \
-        goto fast_next_opcode; \
-    }
-#endif
-
+            f->f_lasti = INSTR_OFFSET(); \ 
+            NEXTOPARG(); \ 
+            goto *opcode_targets[opcode]; \ 
+        } \ 
+        goto fast_next_opcode; \ 
+    } 
+#endif 
+ 
 #define DISPATCH() \
     { \
         if (!_Py_atomic_load_relaxed(eval_breaker)) { \
@@ -1046,106 +1046,106 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
         continue; \
     }
 
-#else
+#else 
 #define TARGET(op) op
 #define FAST_DISPATCH() goto fast_next_opcode
-#define DISPATCH() continue
-#endif
-
-
-/* Tuple access macros */
-
-#ifndef Py_DEBUG
-#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
-#else
-#define GETITEM(v, i) PyTuple_GetItem((v), (i))
-#endif
-
-/* Code access macros */
-
-/* The integer overflow is checked by an assertion below. */
-#define INSTR_OFFSET()  \
-    (sizeof(_Py_CODEUNIT) * (int)(next_instr - first_instr))
-#define NEXTOPARG()  do { \
-        _Py_CODEUNIT word = *next_instr; \
-        opcode = _Py_OPCODE(word); \
-        oparg = _Py_OPARG(word); \
-        next_instr++; \
-    } while (0)
-#define JUMPTO(x)       (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT))
-#define JUMPBY(x)       (next_instr += (x) / sizeof(_Py_CODEUNIT))
-
-/* OpCode prediction macros
-    Some opcodes tend to come in pairs thus making it possible to
-    predict the second code when the first is run.  For example,
-    COMPARE_OP is often followed by POP_JUMP_IF_FALSE or POP_JUMP_IF_TRUE.
-
-    Verifying the prediction costs a single high-speed test of a register
-    variable against a constant.  If the pairing was good, then the
-    processor's own internal branch predication has a high likelihood of
-    success, resulting in a nearly zero-overhead transition to the
-    next opcode.  A successful prediction saves a trip through the eval-loop
-    including its unpredictable switch-case branch.  Combined with the
-    processor's internal branch prediction, a successful PREDICT has the
-    effect of making the two opcodes run as if they were a single new opcode
-    with the bodies combined.
-
-    If collecting opcode statistics, your choices are to either keep the
-    predictions turned-on and interpret the results as if some opcodes
-    had been combined or turn-off predictions so that the opcode frequency
-    counter updates for both opcodes.
-
-    Opcode prediction is disabled with threaded code, since the latter allows
-    the CPU to record separate branch prediction information for each
-    opcode.
-
-*/
-
+#define DISPATCH() continue 
+#endif 
+ 
+ 
+/* Tuple access macros */ 
+ 
+#ifndef Py_DEBUG 
+#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i)) 
+#else 
+#define GETITEM(v, i) PyTuple_GetItem((v), (i)) 
+#endif 
+ 
+/* Code access macros */ 
+ 
+/* The integer overflow is checked by an assertion below. */ 
+#define INSTR_OFFSET()  \ 
+    (sizeof(_Py_CODEUNIT) * (int)(next_instr - first_instr)) 
+#define NEXTOPARG()  do { \ 
+        _Py_CODEUNIT word = *next_instr; \ 
+        opcode = _Py_OPCODE(word); \ 
+        oparg = _Py_OPARG(word); \ 
+        next_instr++; \ 
+    } while (0) 
+#define JUMPTO(x)       (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT)) 
+#define JUMPBY(x)       (next_instr += (x) / sizeof(_Py_CODEUNIT)) 
+ 
+/* OpCode prediction macros 
+    Some opcodes tend to come in pairs thus making it possible to 
+    predict the second code when the first is run.  For example, 
+    COMPARE_OP is often followed by POP_JUMP_IF_FALSE or POP_JUMP_IF_TRUE. 
+ 
+    Verifying the prediction costs a single high-speed test of a register 
+    variable against a constant.  If the pairing was good, then the 
+    processor's own internal branch predication has a high likelihood of 
+    success, resulting in a nearly zero-overhead transition to the 
+    next opcode.  A successful prediction saves a trip through the eval-loop 
+    including its unpredictable switch-case branch.  Combined with the 
+    processor's internal branch prediction, a successful PREDICT has the 
+    effect of making the two opcodes run as if they were a single new opcode 
+    with the bodies combined. 
+ 
+    If collecting opcode statistics, your choices are to either keep the 
+    predictions turned-on and interpret the results as if some opcodes 
+    had been combined or turn-off predictions so that the opcode frequency 
+    counter updates for both opcodes. 
+ 
+    Opcode prediction is disabled with threaded code, since the latter allows 
+    the CPU to record separate branch prediction information for each 
+    opcode. 
+ 
+*/ 
+ 
 #define PREDICT_ID(op)          PRED_##op
 
-#if defined(DYNAMIC_EXECUTION_PROFILE) || USE_COMPUTED_GOTOS
+#if defined(DYNAMIC_EXECUTION_PROFILE) || USE_COMPUTED_GOTOS 
 #define PREDICT(op)             if (0) goto PREDICT_ID(op)
-#else
-#define PREDICT(op) \
+#else 
+#define PREDICT(op) \ 
     do { \
-        _Py_CODEUNIT word = *next_instr; \
-        opcode = _Py_OPCODE(word); \
+        _Py_CODEUNIT word = *next_instr; \ 
+        opcode = _Py_OPCODE(word); \ 
         if (opcode == op) { \
-            oparg = _Py_OPARG(word); \
-            next_instr++; \
+            oparg = _Py_OPARG(word); \ 
+            next_instr++; \ 
             goto PREDICT_ID(op); \
-        } \
-    } while(0)
-#endif
+        } \ 
+    } while(0) 
+#endif 
 #define PREDICTED(op)           PREDICT_ID(op):
-
-
-/* Stack manipulation macros */
-
-/* The stack can grow at most MAXINT deep, as co_nlocals and
-   co_stacksize are ints. */
-#define STACK_LEVEL()     ((int)(stack_pointer - f->f_valuestack))
-#define EMPTY()           (STACK_LEVEL() == 0)
-#define TOP()             (stack_pointer[-1])
-#define SECOND()          (stack_pointer[-2])
-#define THIRD()           (stack_pointer[-3])
-#define FOURTH()          (stack_pointer[-4])
-#define PEEK(n)           (stack_pointer[-(n)])
-#define SET_TOP(v)        (stack_pointer[-1] = (v))
-#define SET_SECOND(v)     (stack_pointer[-2] = (v))
-#define SET_THIRD(v)      (stack_pointer[-3] = (v))
-#define SET_FOURTH(v)     (stack_pointer[-4] = (v))
-#define SET_VALUE(n, v)   (stack_pointer[-(n)] = (v))
-#define BASIC_STACKADJ(n) (stack_pointer += n)
-#define BASIC_PUSH(v)     (*stack_pointer++ = (v))
-#define BASIC_POP()       (*--stack_pointer)
-
-#ifdef LLTRACE
-#define PUSH(v)         { (void)(BASIC_PUSH(v), \
+ 
+ 
+/* Stack manipulation macros */ 
+ 
+/* The stack can grow at most MAXINT deep, as co_nlocals and 
+   co_stacksize are ints. */ 
+#define STACK_LEVEL()     ((int)(stack_pointer - f->f_valuestack)) 
+#define EMPTY()           (STACK_LEVEL() == 0) 
+#define TOP()             (stack_pointer[-1]) 
+#define SECOND()          (stack_pointer[-2]) 
+#define THIRD()           (stack_pointer[-3]) 
+#define FOURTH()          (stack_pointer[-4]) 
+#define PEEK(n)           (stack_pointer[-(n)]) 
+#define SET_TOP(v)        (stack_pointer[-1] = (v)) 
+#define SET_SECOND(v)     (stack_pointer[-2] = (v)) 
+#define SET_THIRD(v)      (stack_pointer[-3] = (v)) 
+#define SET_FOURTH(v)     (stack_pointer[-4] = (v)) 
+#define SET_VALUE(n, v)   (stack_pointer[-(n)] = (v)) 
+#define BASIC_STACKADJ(n) (stack_pointer += n) 
+#define BASIC_PUSH(v)     (*stack_pointer++ = (v)) 
+#define BASIC_POP()       (*--stack_pointer) 
+ 
+#ifdef LLTRACE 
+#define PUSH(v)         { (void)(BASIC_PUSH(v), \ 
                           lltrace && prtrace(tstate, TOP(), "push")); \
-                          assert(STACK_LEVEL() <= co->co_stacksize); }
+                          assert(STACK_LEVEL() <= co->co_stacksize); } 
 #define POP()           ((void)(lltrace && prtrace(tstate, TOP(), "pop")), \
-                         BASIC_POP())
+                         BASIC_POP()) 
 #define STACK_GROW(n)   do { \
                           assert(n >= 0); \
                           (void)(BASIC_STACKADJ(n), \
@@ -1158,59 +1158,59 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
                             (void)(BASIC_STACKADJ(-n)); \
                             assert(STACK_LEVEL() <= co->co_stacksize); \
                         } while (0)
-#define EXT_POP(STACK_POINTER) ((void)(lltrace && \
+#define EXT_POP(STACK_POINTER) ((void)(lltrace && \ 
                                 prtrace(tstate, (STACK_POINTER)[-1], "ext_pop")), \
-                                *--(STACK_POINTER))
-#else
-#define PUSH(v)                BASIC_PUSH(v)
-#define POP()                  BASIC_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 EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
-#endif
-
-/* Local variable macros */
-
-#define GETLOCAL(i)     (fastlocals[i])
-
-/* The SETLOCAL() macro must not DECREF the local variable in-place and
-   then store the new value; it must copy the old value to a temporary
-   value, then store the new value, and then DECREF the temporary value.
-   This is because it is possible that during the DECREF the frame is
-   accessed by other code (e.g. a __del__ method or gc.collect()) and the
-   variable would be pointing to already-freed memory. */
-#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \
-                                     GETLOCAL(i) = value; \
-                                     Py_XDECREF(tmp); } while (0)
-
-
-#define UNWIND_BLOCK(b) \
-    while (STACK_LEVEL() > (b)->b_level) { \
-        PyObject *v = POP(); \
-        Py_XDECREF(v); \
-    }
-
-#define UNWIND_EXCEPT_HANDLER(b) \
-    do { \
-        PyObject *type, *value, *traceback; \
-        _PyErr_StackItem *exc_info; \
-        assert(STACK_LEVEL() >= (b)->b_level + 3); \
-        while (STACK_LEVEL() > (b)->b_level + 3) { \
-            value = POP(); \
-            Py_XDECREF(value); \
-        } \
-        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); \
-    } while(0)
-
+#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER)) 
+#endif 
+ 
+/* Local variable macros */ 
+ 
+#define GETLOCAL(i)     (fastlocals[i]) 
+ 
+/* The SETLOCAL() macro must not DECREF the local variable in-place and 
+   then store the new value; it must copy the old value to a temporary 
+   value, then store the new value, and then DECREF the temporary value. 
+   This is because it is possible that during the DECREF the frame is 
+   accessed by other code (e.g. a __del__ method or gc.collect()) and the 
+   variable would be pointing to already-freed memory. */ 
+#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \ 
+                                     GETLOCAL(i) = value; \ 
+                                     Py_XDECREF(tmp); } while (0) 
+ 
+ 
+#define UNWIND_BLOCK(b) \ 
+    while (STACK_LEVEL() > (b)->b_level) { \ 
+        PyObject *v = POP(); \ 
+        Py_XDECREF(v); \ 
+    } 
+ 
+#define UNWIND_EXCEPT_HANDLER(b) \ 
+    do { \ 
+        PyObject *type, *value, *traceback; \ 
+        _PyErr_StackItem *exc_info; \ 
+        assert(STACK_LEVEL() >= (b)->b_level + 3); \ 
+        while (STACK_LEVEL() > (b)->b_level + 3) { \ 
+            value = POP(); \ 
+            Py_XDECREF(value); \ 
+        } \ 
+        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); \ 
+    } while(0) 
+ 
     /* macros for opcode cache */
 #define OPCACHE_CHECK() \
     do { \
@@ -1251,88 +1251,88 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 
 #endif
 
-/* Start of code */
-
-    /* push frame */
+/* Start of code */ 
+ 
+    /* push frame */ 
     if (_Py_EnterRecursiveCall(tstate, "")) {
-        return NULL;
-    }
-
-    tstate->frame = f;
-
-    if (tstate->use_tracing) {
-        if (tstate->c_tracefunc != NULL) {
-            /* tstate->c_tracefunc, if defined, is a
-               function that will be called on *every* entry
-               to a code block.  Its return value, if not
-               None, is a function that will be called at
-               the start of each executed line of code.
-               (Actually, the function must return itself
-               in order to continue tracing.)  The trace
-               functions are called with three arguments:
-               a pointer to the current frame, a string
-               indicating why the function is called, and
-               an argument which depends on the situation.
-               The global trace function is also called
-               whenever an exception is detected. */
-            if (call_trace_protected(tstate->c_tracefunc,
-                                     tstate->c_traceobj,
-                                     tstate, f, PyTrace_CALL, Py_None)) {
-                /* Trace function raised an error */
-                goto exit_eval_frame;
-            }
-        }
-        if (tstate->c_profilefunc != NULL) {
-            /* Similar for c_profilefunc, except it needn't
-               return itself and isn't called for "line" events */
-            if (call_trace_protected(tstate->c_profilefunc,
-                                     tstate->c_profileobj,
-                                     tstate, f, PyTrace_CALL, Py_None)) {
-                /* Profile function raised an error */
-                goto exit_eval_frame;
-            }
-        }
-    }
-
-    if (PyDTrace_FUNCTION_ENTRY_ENABLED())
-        dtrace_function_entry(f);
-
-    co = f->f_code;
-    names = co->co_names;
-    consts = co->co_consts;
-    fastlocals = f->f_localsplus;
-    freevars = f->f_localsplus + co->co_nlocals;
-    assert(PyBytes_Check(co->co_code));
-    assert(PyBytes_GET_SIZE(co->co_code) <= INT_MAX);
-    assert(PyBytes_GET_SIZE(co->co_code) % sizeof(_Py_CODEUNIT) == 0);
-    assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(co->co_code), sizeof(_Py_CODEUNIT)));
-    first_instr = (_Py_CODEUNIT *) PyBytes_AS_STRING(co->co_code);
-    /*
-       f->f_lasti refers to the index of the last instruction,
-       unless it's -1 in which case next_instr should be first_instr.
-
-       YIELD_FROM sets f_lasti to itself, in order to repeatedly yield
-       multiple values.
-
-       When the PREDICT() macros are enabled, some opcode pairs follow in
-       direct succession without updating f->f_lasti.  A successful
-       prediction effectively links the two codes together as if they
-       were a single new opcode; accordingly,f->f_lasti will point to
-       the first code in the pair (for instance, GET_ITER followed by
-       FOR_ITER is effectively a single opcode and f->f_lasti will point
-       to the beginning of the combined pair.)
-    */
-    assert(f->f_lasti >= -1);
-    next_instr = first_instr;
-    if (f->f_lasti >= 0) {
-        assert(f->f_lasti % sizeof(_Py_CODEUNIT) == 0);
-        next_instr += f->f_lasti / sizeof(_Py_CODEUNIT) + 1;
-    }
-    stack_pointer = f->f_stacktop;
-    assert(stack_pointer != NULL);
-    f->f_stacktop = NULL;       /* remains NULL unless yield suspends frame */
-    f->f_executing = 1;
-
+        return NULL; 
+    }
+ 
+    tstate->frame = f; 
+ 
+    if (tstate->use_tracing) { 
+        if (tstate->c_tracefunc != NULL) { 
+            /* tstate->c_tracefunc, if defined, is a 
+               function that will be called on *every* entry 
+               to a code block.  Its return value, if not 
+               None, is a function that will be called at 
+               the start of each executed line of code. 
+               (Actually, the function must return itself 
+               in order to continue tracing.)  The trace 
+               functions are called with three arguments: 
+               a pointer to the current frame, a string 
+               indicating why the function is called, and 
+               an argument which depends on the situation. 
+               The global trace function is also called 
+               whenever an exception is detected. */ 
+            if (call_trace_protected(tstate->c_tracefunc, 
+                                     tstate->c_traceobj, 
+                                     tstate, f, PyTrace_CALL, Py_None)) { 
+                /* Trace function raised an error */ 
+                goto exit_eval_frame; 
+            } 
+        } 
+        if (tstate->c_profilefunc != NULL) { 
+            /* Similar for c_profilefunc, except it needn't 
+               return itself and isn't called for "line" events */ 
+            if (call_trace_protected(tstate->c_profilefunc, 
+                                     tstate->c_profileobj, 
+                                     tstate, f, PyTrace_CALL, Py_None)) { 
+                /* Profile function raised an error */ 
+                goto exit_eval_frame; 
+            } 
+        } 
+    } 
+ 
+    if (PyDTrace_FUNCTION_ENTRY_ENABLED()) 
+        dtrace_function_entry(f); 
+ 
+    co = f->f_code; 
+    names = co->co_names; 
+    consts = co->co_consts; 
+    fastlocals = f->f_localsplus; 
+    freevars = f->f_localsplus + co->co_nlocals; 
+    assert(PyBytes_Check(co->co_code)); 
+    assert(PyBytes_GET_SIZE(co->co_code) <= INT_MAX); 
+    assert(PyBytes_GET_SIZE(co->co_code) % sizeof(_Py_CODEUNIT) == 0); 
+    assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(co->co_code), sizeof(_Py_CODEUNIT))); 
+    first_instr = (_Py_CODEUNIT *) PyBytes_AS_STRING(co->co_code); 
+    /* 
+       f->f_lasti refers to the index of the last instruction, 
+       unless it's -1 in which case next_instr should be first_instr. 
+ 
+       YIELD_FROM sets f_lasti to itself, in order to repeatedly yield 
+       multiple values. 
+ 
+       When the PREDICT() macros are enabled, some opcode pairs follow in 
+       direct succession without updating f->f_lasti.  A successful 
+       prediction effectively links the two codes together as if they 
+       were a single new opcode; accordingly,f->f_lasti will point to 
+       the first code in the pair (for instance, GET_ITER followed by 
+       FOR_ITER is effectively a single opcode and f->f_lasti will point 
+       to the beginning of the combined pair.) 
+    */ 
+    assert(f->f_lasti >= -1); 
+    next_instr = first_instr; 
+    if (f->f_lasti >= 0) { 
+        assert(f->f_lasti % sizeof(_Py_CODEUNIT) == 0); 
+        next_instr += f->f_lasti / sizeof(_Py_CODEUNIT) + 1; 
+    } 
+    stack_pointer = f->f_stacktop; 
+    assert(stack_pointer != NULL); 
+    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) {
@@ -1347,186 +1347,186 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 #endif
         }
     }
-
-#ifdef LLTRACE
-    lltrace = _PyDict_GetItemId(f->f_globals, &PyId___ltrace__) != NULL;
-#endif
-
-    if (throwflag) /* support for generator.throw() */
-        goto error;
-
-#ifdef Py_DEBUG
+ 
+#ifdef LLTRACE 
+    lltrace = _PyDict_GetItemId(f->f_globals, &PyId___ltrace__) != NULL; 
+#endif 
+ 
+    if (throwflag) /* support for generator.throw() */ 
+        goto error; 
+ 
+#ifdef Py_DEBUG 
     /* _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 */
+       because it can clear it (directly or indirectly) and so the 
+       caller loses its exception */ 
     assert(!_PyErr_Occurred(tstate));
-#endif
-
+#endif 
+ 
 main_loop:
-    for (;;) {
-        assert(stack_pointer >= f->f_valuestack); /* else underflow */
-        assert(STACK_LEVEL() <= co->co_stacksize);  /* else overflow */
+    for (;;) { 
+        assert(stack_pointer >= f->f_valuestack); /* else underflow */ 
+        assert(STACK_LEVEL() <= co->co_stacksize);  /* else overflow */ 
         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
+ 
+        /* 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
-           event needs attention (e.g. a signal handler or
-           async I/O handler); see Py_AddPendingCall() and
-           Py_MakePendingCalls() above. */
-
+           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)) {
-            opcode = _Py_OPCODE(*next_instr);
-            if (opcode == SETUP_FINALLY ||
-                opcode == SETUP_WITH ||
-                opcode == BEFORE_ASYNC_WITH ||
-                opcode == YIELD_FROM) {
-                /* Few cases where we skip running signal handlers and other
-                   pending calls:
-                   - If we're about to enter the 'with:'. It will prevent
-                     emitting a resource warning in the common idiom
-                     'with open(path) as file:'.
-                   - If we're about to enter the 'async with:'.
-                   - If we're about to enter the 'try:' of a try/finally (not
-                     *very* useful, but might help in some cases and it's
-                     traditional)
-                   - If we're resuming a chain of nested 'yield from' or
-                     'await' calls, then each frame is parked with YIELD_FROM
-                     as its next opcode. If the user hit control-C we want to
-                     wait until we've reached the innermost frame before
-                     running the signal handler and raising KeyboardInterrupt
-                     (see bpo-30039).
-                */
-                goto fast_next_opcode;
-            }
+            opcode = _Py_OPCODE(*next_instr); 
+            if (opcode == SETUP_FINALLY || 
+                opcode == SETUP_WITH || 
+                opcode == BEFORE_ASYNC_WITH || 
+                opcode == YIELD_FROM) { 
+                /* Few cases where we skip running signal handlers and other 
+                   pending calls: 
+                   - If we're about to enter the 'with:'. It will prevent 
+                     emitting a resource warning in the common idiom 
+                     'with open(path) as file:'. 
+                   - If we're about to enter the 'async with:'. 
+                   - If we're about to enter the 'try:' of a try/finally (not 
+                     *very* useful, but might help in some cases and it's 
+                     traditional) 
+                   - If we're resuming a chain of nested 'yield from' or 
+                     'await' calls, then each frame is parked with YIELD_FROM 
+                     as its next opcode. If the user hit control-C we want to 
+                     wait until we've reached the innermost frame before 
+                     running the signal handler and raising KeyboardInterrupt 
+                     (see bpo-30039). 
+                */ 
+                goto fast_next_opcode; 
+            } 
 
             if (eval_frame_handle_pending(tstate) != 0) {
-                goto error;
-            }
-        }
-
-    fast_next_opcode:
-        f->f_lasti = INSTR_OFFSET();
-
-        if (PyDTrace_LINE_ENABLED())
-            maybe_dtrace_line(f, &instr_lb, &instr_ub, &instr_prev);
-
-        /* line-by-line tracing support */
-
+                goto error; 
+            } 
+        } 
+ 
+    fast_next_opcode: 
+        f->f_lasti = INSTR_OFFSET(); 
+ 
+        if (PyDTrace_LINE_ENABLED()) 
+            maybe_dtrace_line(f, &instr_lb, &instr_ub, &instr_prev); 
+ 
+        /* line-by-line tracing support */ 
+ 
         if (_Py_TracingPossible(ceval2) &&
-            tstate->c_tracefunc != NULL && !tstate->tracing) {
-            int err;
-            /* see maybe_call_line_trace
-               for expository comments */
-            f->f_stacktop = stack_pointer;
-
-            err = maybe_call_line_trace(tstate->c_tracefunc,
-                                        tstate->c_traceobj,
-                                        tstate, f,
-                                        &instr_lb, &instr_ub, &instr_prev);
-            /* Reload possibly changed frame fields */
-            JUMPTO(f->f_lasti);
-            if (f->f_stacktop != NULL) {
-                stack_pointer = f->f_stacktop;
-                f->f_stacktop = NULL;
-            }
-            if (err)
-                /* trace function raised an exception */
-                goto error;
-        }
-
-        /* Extract opcode and argument */
-
-        NEXTOPARG();
-    dispatch_opcode:
-#ifdef DYNAMIC_EXECUTION_PROFILE
-#ifdef DXPAIRS
-        dxpairs[lastopcode][opcode]++;
-        lastopcode = opcode;
-#endif
-        dxp[opcode]++;
-#endif
-
-#ifdef LLTRACE
-        /* Instruction tracing */
-
-        if (lltrace) {
-            if (HAS_ARG(opcode)) {
-                printf("%d: %d, %d\n",
-                       f->f_lasti, opcode, oparg);
-            }
-            else {
-                printf("%d: %d\n",
-                       f->f_lasti, opcode);
-            }
-        }
-#endif
-
-        switch (opcode) {
-
-        /* BEWARE!
+            tstate->c_tracefunc != NULL && !tstate->tracing) { 
+            int err; 
+            /* see maybe_call_line_trace 
+               for expository comments */ 
+            f->f_stacktop = stack_pointer; 
+ 
+            err = maybe_call_line_trace(tstate->c_tracefunc, 
+                                        tstate->c_traceobj, 
+                                        tstate, f, 
+                                        &instr_lb, &instr_ub, &instr_prev); 
+            /* Reload possibly changed frame fields */ 
+            JUMPTO(f->f_lasti); 
+            if (f->f_stacktop != NULL) { 
+                stack_pointer = f->f_stacktop; 
+                f->f_stacktop = NULL; 
+            } 
+            if (err) 
+                /* trace function raised an exception */ 
+                goto error; 
+        } 
+ 
+        /* Extract opcode and argument */ 
+ 
+        NEXTOPARG(); 
+    dispatch_opcode: 
+#ifdef DYNAMIC_EXECUTION_PROFILE 
+#ifdef DXPAIRS 
+        dxpairs[lastopcode][opcode]++; 
+        lastopcode = opcode; 
+#endif 
+        dxp[opcode]++; 
+#endif 
+ 
+#ifdef LLTRACE 
+        /* Instruction tracing */ 
+ 
+        if (lltrace) { 
+            if (HAS_ARG(opcode)) { 
+                printf("%d: %d, %d\n", 
+                       f->f_lasti, opcode, oparg); 
+            } 
+            else { 
+                printf("%d: %d\n", 
+                       f->f_lasti, opcode); 
+            } 
+        } 
+#endif 
+ 
+        switch (opcode) { 
+ 
+        /* BEWARE! 
            It is essential that any operation that fails must goto error
            and that all operation that succeed call [FAST_]DISPATCH() ! */
-
+ 
         case TARGET(NOP): {
-            FAST_DISPATCH();
+            FAST_DISPATCH(); 
         }
-
+ 
         case TARGET(LOAD_FAST): {
-            PyObject *value = GETLOCAL(oparg);
-            if (value == NULL) {
+            PyObject *value = GETLOCAL(oparg); 
+            if (value == NULL) { 
                 format_exc_check_arg(tstate, PyExc_UnboundLocalError,
-                                     UNBOUNDLOCAL_ERROR_MSG,
-                                     PyTuple_GetItem(co->co_varnames, oparg));
-                goto error;
-            }
-            Py_INCREF(value);
-            PUSH(value);
-            FAST_DISPATCH();
-        }
-
+                                     UNBOUNDLOCAL_ERROR_MSG, 
+                                     PyTuple_GetItem(co->co_varnames, oparg)); 
+                goto error; 
+            } 
+            Py_INCREF(value); 
+            PUSH(value); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_CONST): {
             PREDICTED(LOAD_CONST);
-            PyObject *value = GETITEM(consts, oparg);
-            Py_INCREF(value);
-            PUSH(value);
-            FAST_DISPATCH();
-        }
-
+            PyObject *value = GETITEM(consts, oparg); 
+            Py_INCREF(value); 
+            PUSH(value); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(STORE_FAST): {
             PREDICTED(STORE_FAST);
-            PyObject *value = POP();
-            SETLOCAL(oparg, value);
-            FAST_DISPATCH();
-        }
-
+            PyObject *value = POP(); 
+            SETLOCAL(oparg, value); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(POP_TOP): {
-            PyObject *value = POP();
-            Py_DECREF(value);
-            FAST_DISPATCH();
-        }
-
+            PyObject *value = POP(); 
+            Py_DECREF(value); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(ROT_TWO): {
-            PyObject *top = TOP();
-            PyObject *second = SECOND();
-            SET_TOP(second);
-            SET_SECOND(top);
-            FAST_DISPATCH();
-        }
-
+            PyObject *top = TOP(); 
+            PyObject *second = SECOND(); 
+            SET_TOP(second); 
+            SET_SECOND(top); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(ROT_THREE): {
-            PyObject *top = TOP();
-            PyObject *second = SECOND();
-            PyObject *third = THIRD();
-            SET_TOP(second);
-            SET_SECOND(third);
-            SET_THIRD(top);
-            FAST_DISPATCH();
-        }
-
+            PyObject *top = TOP(); 
+            PyObject *second = SECOND(); 
+            PyObject *third = THIRD(); 
+            SET_TOP(second); 
+            SET_SECOND(third); 
+            SET_THIRD(top); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(ROT_FOUR): {
-            PyObject *top = TOP();
+            PyObject *top = TOP(); 
             PyObject *second = SECOND();
             PyObject *third = THIRD();
             PyObject *fourth = FOURTH();
@@ -1539,721 +1539,721 @@ main_loop:
 
         case TARGET(DUP_TOP): {
             PyObject *top = TOP();
-            Py_INCREF(top);
-            PUSH(top);
-            FAST_DISPATCH();
-        }
-
+            Py_INCREF(top); 
+            PUSH(top); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(DUP_TOP_TWO): {
-            PyObject *top = TOP();
-            PyObject *second = SECOND();
-            Py_INCREF(top);
-            Py_INCREF(second);
+            PyObject *top = TOP(); 
+            PyObject *second = SECOND(); 
+            Py_INCREF(top); 
+            Py_INCREF(second); 
             STACK_GROW(2);
-            SET_TOP(top);
-            SET_SECOND(second);
-            FAST_DISPATCH();
-        }
-
+            SET_TOP(top); 
+            SET_SECOND(second); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(UNARY_POSITIVE): {
-            PyObject *value = TOP();
-            PyObject *res = PyNumber_Positive(value);
-            Py_DECREF(value);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *value = TOP(); 
+            PyObject *res = PyNumber_Positive(value); 
+            Py_DECREF(value); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(UNARY_NEGATIVE): {
-            PyObject *value = TOP();
-            PyObject *res = PyNumber_Negative(value);
-            Py_DECREF(value);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *value = TOP(); 
+            PyObject *res = PyNumber_Negative(value); 
+            Py_DECREF(value); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(UNARY_NOT): {
-            PyObject *value = TOP();
-            int err = PyObject_IsTrue(value);
-            Py_DECREF(value);
-            if (err == 0) {
-                Py_INCREF(Py_True);
-                SET_TOP(Py_True);
-                DISPATCH();
-            }
-            else if (err > 0) {
-                Py_INCREF(Py_False);
-                SET_TOP(Py_False);
-                DISPATCH();
-            }
+            PyObject *value = TOP(); 
+            int err = PyObject_IsTrue(value); 
+            Py_DECREF(value); 
+            if (err == 0) { 
+                Py_INCREF(Py_True); 
+                SET_TOP(Py_True); 
+                DISPATCH(); 
+            } 
+            else if (err > 0) { 
+                Py_INCREF(Py_False); 
+                SET_TOP(Py_False); 
+                DISPATCH(); 
+            } 
             STACK_SHRINK(1);
-            goto error;
-        }
-
+            goto error; 
+        } 
+ 
         case TARGET(UNARY_INVERT): {
-            PyObject *value = TOP();
-            PyObject *res = PyNumber_Invert(value);
-            Py_DECREF(value);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *value = TOP(); 
+            PyObject *res = PyNumber_Invert(value); 
+            Py_DECREF(value); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_POWER): {
-            PyObject *exp = POP();
-            PyObject *base = TOP();
-            PyObject *res = PyNumber_Power(base, exp, Py_None);
-            Py_DECREF(base);
-            Py_DECREF(exp);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *exp = POP(); 
+            PyObject *base = TOP(); 
+            PyObject *res = PyNumber_Power(base, exp, Py_None); 
+            Py_DECREF(base); 
+            Py_DECREF(exp); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_MULTIPLY): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_Multiply(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_Multiply(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_MATRIX_MULTIPLY): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_MatrixMultiply(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_MatrixMultiply(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_TRUE_DIVIDE): {
-            PyObject *divisor = POP();
-            PyObject *dividend = TOP();
-            PyObject *quotient = PyNumber_TrueDivide(dividend, divisor);
-            Py_DECREF(dividend);
-            Py_DECREF(divisor);
-            SET_TOP(quotient);
-            if (quotient == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *divisor = POP(); 
+            PyObject *dividend = TOP(); 
+            PyObject *quotient = PyNumber_TrueDivide(dividend, divisor); 
+            Py_DECREF(dividend); 
+            Py_DECREF(divisor); 
+            SET_TOP(quotient); 
+            if (quotient == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_FLOOR_DIVIDE): {
-            PyObject *divisor = POP();
-            PyObject *dividend = TOP();
-            PyObject *quotient = PyNumber_FloorDivide(dividend, divisor);
-            Py_DECREF(dividend);
-            Py_DECREF(divisor);
-            SET_TOP(quotient);
-            if (quotient == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *divisor = POP(); 
+            PyObject *dividend = TOP(); 
+            PyObject *quotient = PyNumber_FloorDivide(dividend, divisor); 
+            Py_DECREF(dividend); 
+            Py_DECREF(divisor); 
+            SET_TOP(quotient); 
+            if (quotient == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_MODULO): {
-            PyObject *divisor = POP();
-            PyObject *dividend = TOP();
-            PyObject *res;
-            if (PyUnicode_CheckExact(dividend) && (
-                  !PyUnicode_Check(divisor) || PyUnicode_CheckExact(divisor))) {
-              // fast path; string formatting, but not if the RHS is a str subclass
-              // (see issue28598)
-              res = PyUnicode_Format(dividend, divisor);
-            } else {
-              res = PyNumber_Remainder(dividend, divisor);
-            }
-            Py_DECREF(divisor);
-            Py_DECREF(dividend);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *divisor = POP(); 
+            PyObject *dividend = TOP(); 
+            PyObject *res; 
+            if (PyUnicode_CheckExact(dividend) && ( 
+                  !PyUnicode_Check(divisor) || PyUnicode_CheckExact(divisor))) { 
+              // fast path; string formatting, but not if the RHS is a str subclass 
+              // (see issue28598) 
+              res = PyUnicode_Format(dividend, divisor); 
+            } else { 
+              res = PyNumber_Remainder(dividend, divisor); 
+            } 
+            Py_DECREF(divisor); 
+            Py_DECREF(dividend); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_ADD): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *sum;
-            /* NOTE(haypo): Please don't try to micro-optimize int+int on
-               CPython using bytecode, it is simply worthless.
-               See http://bugs.python.org/issue21955 and
-               http://bugs.python.org/issue10044 for the discussion. In short,
-               no patch shown any impact on a realistic benchmark, only a minor
-               speedup on microbenchmarks. */
-            if (PyUnicode_CheckExact(left) &&
-                     PyUnicode_CheckExact(right)) {
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *sum; 
+            /* NOTE(haypo): Please don't try to micro-optimize int+int on 
+               CPython using bytecode, it is simply worthless. 
+               See http://bugs.python.org/issue21955 and 
+               http://bugs.python.org/issue10044 for the discussion. In short, 
+               no patch shown any impact on a realistic benchmark, only a minor 
+               speedup on microbenchmarks. */ 
+            if (PyUnicode_CheckExact(left) && 
+                     PyUnicode_CheckExact(right)) { 
                 sum = unicode_concatenate(tstate, left, right, f, next_instr);
-                /* unicode_concatenate consumed the ref to left */
-            }
-            else {
-                sum = PyNumber_Add(left, right);
-                Py_DECREF(left);
-            }
-            Py_DECREF(right);
-            SET_TOP(sum);
-            if (sum == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+                /* unicode_concatenate consumed the ref to left */ 
+            } 
+            else { 
+                sum = PyNumber_Add(left, right); 
+                Py_DECREF(left); 
+            } 
+            Py_DECREF(right); 
+            SET_TOP(sum); 
+            if (sum == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_SUBTRACT): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *diff = PyNumber_Subtract(left, right);
-            Py_DECREF(right);
-            Py_DECREF(left);
-            SET_TOP(diff);
-            if (diff == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *diff = PyNumber_Subtract(left, right); 
+            Py_DECREF(right); 
+            Py_DECREF(left); 
+            SET_TOP(diff); 
+            if (diff == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_SUBSCR): {
-            PyObject *sub = POP();
-            PyObject *container = TOP();
-            PyObject *res = PyObject_GetItem(container, sub);
-            Py_DECREF(container);
-            Py_DECREF(sub);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *sub = POP(); 
+            PyObject *container = TOP(); 
+            PyObject *res = PyObject_GetItem(container, sub); 
+            Py_DECREF(container); 
+            Py_DECREF(sub); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_LSHIFT): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_Lshift(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_Lshift(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_RSHIFT): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_Rshift(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_Rshift(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_AND): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_And(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_And(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_XOR): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_Xor(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_Xor(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BINARY_OR): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_Or(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_Or(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LIST_APPEND): {
-            PyObject *v = POP();
-            PyObject *list = PEEK(oparg);
-            int err;
-            err = PyList_Append(list, v);
-            Py_DECREF(v);
-            if (err != 0)
-                goto error;
-            PREDICT(JUMP_ABSOLUTE);
-            DISPATCH();
-        }
-
+            PyObject *v = POP(); 
+            PyObject *list = PEEK(oparg); 
+            int err; 
+            err = PyList_Append(list, v); 
+            Py_DECREF(v); 
+            if (err != 0) 
+                goto error; 
+            PREDICT(JUMP_ABSOLUTE); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(SET_ADD): {
-            PyObject *v = POP();
-            PyObject *set = PEEK(oparg);
-            int err;
-            err = PySet_Add(set, v);
-            Py_DECREF(v);
-            if (err != 0)
-                goto error;
-            PREDICT(JUMP_ABSOLUTE);
-            DISPATCH();
-        }
-
+            PyObject *v = POP(); 
+            PyObject *set = PEEK(oparg); 
+            int err; 
+            err = PySet_Add(set, v); 
+            Py_DECREF(v); 
+            if (err != 0) 
+                goto error; 
+            PREDICT(JUMP_ABSOLUTE); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_POWER): {
-            PyObject *exp = POP();
-            PyObject *base = TOP();
-            PyObject *res = PyNumber_InPlacePower(base, exp, Py_None);
-            Py_DECREF(base);
-            Py_DECREF(exp);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *exp = POP(); 
+            PyObject *base = TOP(); 
+            PyObject *res = PyNumber_InPlacePower(base, exp, Py_None); 
+            Py_DECREF(base); 
+            Py_DECREF(exp); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_MULTIPLY): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceMultiply(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceMultiply(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_MATRIX_MULTIPLY): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceMatrixMultiply(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceMatrixMultiply(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_TRUE_DIVIDE): {
-            PyObject *divisor = POP();
-            PyObject *dividend = TOP();
-            PyObject *quotient = PyNumber_InPlaceTrueDivide(dividend, divisor);
-            Py_DECREF(dividend);
-            Py_DECREF(divisor);
-            SET_TOP(quotient);
-            if (quotient == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *divisor = POP(); 
+            PyObject *dividend = TOP(); 
+            PyObject *quotient = PyNumber_InPlaceTrueDivide(dividend, divisor); 
+            Py_DECREF(dividend); 
+            Py_DECREF(divisor); 
+            SET_TOP(quotient); 
+            if (quotient == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_FLOOR_DIVIDE): {
-            PyObject *divisor = POP();
-            PyObject *dividend = TOP();
-            PyObject *quotient = PyNumber_InPlaceFloorDivide(dividend, divisor);
-            Py_DECREF(dividend);
-            Py_DECREF(divisor);
-            SET_TOP(quotient);
-            if (quotient == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *divisor = POP(); 
+            PyObject *dividend = TOP(); 
+            PyObject *quotient = PyNumber_InPlaceFloorDivide(dividend, divisor); 
+            Py_DECREF(dividend); 
+            Py_DECREF(divisor); 
+            SET_TOP(quotient); 
+            if (quotient == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_MODULO): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *mod = PyNumber_InPlaceRemainder(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(mod);
-            if (mod == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *mod = PyNumber_InPlaceRemainder(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(mod); 
+            if (mod == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_ADD): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *sum;
-            if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) {
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *sum; 
+            if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) { 
                 sum = unicode_concatenate(tstate, left, right, f, next_instr);
-                /* unicode_concatenate consumed the ref to left */
-            }
-            else {
-                sum = PyNumber_InPlaceAdd(left, right);
-                Py_DECREF(left);
-            }
-            Py_DECREF(right);
-            SET_TOP(sum);
-            if (sum == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+                /* unicode_concatenate consumed the ref to left */ 
+            } 
+            else { 
+                sum = PyNumber_InPlaceAdd(left, right); 
+                Py_DECREF(left); 
+            } 
+            Py_DECREF(right); 
+            SET_TOP(sum); 
+            if (sum == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_SUBTRACT): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *diff = PyNumber_InPlaceSubtract(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(diff);
-            if (diff == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *diff = PyNumber_InPlaceSubtract(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(diff); 
+            if (diff == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_LSHIFT): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceLshift(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceLshift(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_RSHIFT): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceRshift(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceRshift(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_AND): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceAnd(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceAnd(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_XOR): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceXor(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceXor(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(INPLACE_OR): {
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyNumber_InPlaceOr(left, right);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
+            PyObject *res = PyNumber_InPlaceOr(left, right); 
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(STORE_SUBSCR): {
-            PyObject *sub = TOP();
-            PyObject *container = SECOND();
-            PyObject *v = THIRD();
-            int err;
+            PyObject *sub = TOP(); 
+            PyObject *container = SECOND(); 
+            PyObject *v = THIRD(); 
+            int err; 
             STACK_SHRINK(3);
-            /* container[sub] = v */
-            err = PyObject_SetItem(container, sub, v);
-            Py_DECREF(v);
-            Py_DECREF(container);
-            Py_DECREF(sub);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+            /* container[sub] = v */ 
+            err = PyObject_SetItem(container, sub, v); 
+            Py_DECREF(v); 
+            Py_DECREF(container); 
+            Py_DECREF(sub); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DELETE_SUBSCR): {
-            PyObject *sub = TOP();
-            PyObject *container = SECOND();
-            int err;
+            PyObject *sub = TOP(); 
+            PyObject *container = SECOND(); 
+            int err; 
             STACK_SHRINK(2);
-            /* del container[sub] */
-            err = PyObject_DelItem(container, sub);
-            Py_DECREF(container);
-            Py_DECREF(sub);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+            /* del container[sub] */ 
+            err = PyObject_DelItem(container, sub); 
+            Py_DECREF(container); 
+            Py_DECREF(sub); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(PRINT_EXPR): {
-            _Py_IDENTIFIER(displayhook);
-            PyObject *value = POP();
-            PyObject *hook = _PySys_GetObjectId(&PyId_displayhook);
-            PyObject *res;
-            if (hook == NULL) {
+            _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");
-                Py_DECREF(value);
-                goto error;
-            }
+                Py_DECREF(value); 
+                goto error; 
+            } 
             res = PyObject_CallOneArg(hook, value);
-            Py_DECREF(value);
-            if (res == NULL)
-                goto error;
-            Py_DECREF(res);
-            DISPATCH();
-        }
-
+            Py_DECREF(value); 
+            if (res == NULL) 
+                goto error; 
+            Py_DECREF(res); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(RAISE_VARARGS): {
-            PyObject *cause = NULL, *exc = NULL;
-            switch (oparg) {
-            case 2:
-                cause = POP(); /* cause */
-                /* fall through */
-            case 1:
-                exc = POP(); /* exc */
-                /* fall through */
-            case 0:
+            PyObject *cause = NULL, *exc = NULL; 
+            switch (oparg) { 
+            case 2: 
+                cause = POP(); /* cause */ 
+                /* fall through */ 
+            case 1: 
+                exc = POP(); /* exc */ 
+                /* fall through */ 
+            case 0: 
                 if (do_raise(tstate, exc, cause)) {
                     goto exception_unwind;
-                }
-                break;
-            default:
+                } 
+                break; 
+            default: 
                 _PyErr_SetString(tstate, PyExc_SystemError,
                                  "bad RAISE_VARARGS oparg");
-                break;
-            }
-            goto error;
-        }
-
+                break; 
+            } 
+            goto error; 
+        } 
+ 
         case TARGET(RETURN_VALUE): {
-            retval = POP();
+            retval = POP(); 
             assert(f->f_iblock == 0);
             assert(EMPTY());
             goto exiting;
-        }
-
+        } 
+ 
         case TARGET(GET_AITER): {
-            unaryfunc getter = NULL;
-            PyObject *iter = NULL;
-            PyObject *obj = TOP();
-            PyTypeObject *type = Py_TYPE(obj);
-
-            if (type->tp_as_async != NULL) {
-                getter = type->tp_as_async->am_aiter;
-            }
-
-            if (getter != NULL) {
-                iter = (*getter)(obj);
-                Py_DECREF(obj);
-                if (iter == NULL) {
-                    SET_TOP(NULL);
-                    goto error;
-                }
-            }
-            else {
-                SET_TOP(NULL);
+            unaryfunc getter = NULL; 
+            PyObject *iter = NULL; 
+            PyObject *obj = TOP(); 
+            PyTypeObject *type = Py_TYPE(obj); 
+ 
+            if (type->tp_as_async != NULL) { 
+                getter = type->tp_as_async->am_aiter; 
+            } 
+ 
+            if (getter != NULL) { 
+                iter = (*getter)(obj); 
+                Py_DECREF(obj); 
+                if (iter == NULL) { 
+                    SET_TOP(NULL); 
+                    goto error; 
+                } 
+            } 
+            else { 
+                SET_TOP(NULL); 
                 _PyErr_Format(tstate, PyExc_TypeError,
                               "'async for' requires an object with "
                               "__aiter__ method, got %.100s",
                               type->tp_name);
-                Py_DECREF(obj);
-                goto error;
-            }
-
-            if (Py_TYPE(iter)->tp_as_async == NULL ||
-                    Py_TYPE(iter)->tp_as_async->am_anext == NULL) {
-
-                SET_TOP(NULL);
+                Py_DECREF(obj); 
+                goto error; 
+            } 
+ 
+            if (Py_TYPE(iter)->tp_as_async == NULL || 
+                    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);
-                Py_DECREF(iter);
-                goto error;
-            }
-
-            SET_TOP(iter);
-            DISPATCH();
-        }
-
+                Py_DECREF(iter); 
+                goto error; 
+            } 
+ 
+            SET_TOP(iter); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(GET_ANEXT): {
-            unaryfunc getter = NULL;
-            PyObject *next_iter = NULL;
-            PyObject *awaitable = NULL;
-            PyObject *aiter = TOP();
-            PyTypeObject *type = Py_TYPE(aiter);
-
-            if (PyAsyncGen_CheckExact(aiter)) {
-                awaitable = type->tp_as_async->am_anext(aiter);
-                if (awaitable == NULL) {
-                    goto error;
-                }
-            } else {
-                if (type->tp_as_async != NULL){
-                    getter = type->tp_as_async->am_anext;
-                }
-
-                if (getter != NULL) {
-                    next_iter = (*getter)(aiter);
-                    if (next_iter == NULL) {
-                        goto error;
-                    }
-                }
-                else {
+            unaryfunc getter = NULL; 
+            PyObject *next_iter = NULL; 
+            PyObject *awaitable = NULL; 
+            PyObject *aiter = TOP(); 
+            PyTypeObject *type = Py_TYPE(aiter); 
+ 
+            if (PyAsyncGen_CheckExact(aiter)) { 
+                awaitable = type->tp_as_async->am_anext(aiter); 
+                if (awaitable == NULL) { 
+                    goto error; 
+                } 
+            } else { 
+                if (type->tp_as_async != NULL){ 
+                    getter = type->tp_as_async->am_anext; 
+                } 
+ 
+                if (getter != NULL) { 
+                    next_iter = (*getter)(aiter); 
+                    if (next_iter == NULL) { 
+                        goto error; 
+                    } 
+                } 
+                else { 
                     _PyErr_Format(tstate, PyExc_TypeError,
                                   "'async for' requires an iterator with "
                                   "__anext__ method, got %.100s",
                                   type->tp_name);
-                    goto error;
-                }
-
-                awaitable = _PyCoro_GetAwaitableIter(next_iter);
-                if (awaitable == NULL) {
-                    _PyErr_FormatFromCause(
-                        PyExc_TypeError,
-                        "'async for' received an invalid object "
-                        "from __anext__: %.100s",
-                        Py_TYPE(next_iter)->tp_name);
-
-                    Py_DECREF(next_iter);
-                    goto error;
-                } else {
-                    Py_DECREF(next_iter);
-                }
-            }
-
-            PUSH(awaitable);
-            PREDICT(LOAD_CONST);
-            DISPATCH();
-        }
-
+                    goto error; 
+                } 
+ 
+                awaitable = _PyCoro_GetAwaitableIter(next_iter); 
+                if (awaitable == NULL) { 
+                    _PyErr_FormatFromCause( 
+                        PyExc_TypeError, 
+                        "'async for' received an invalid object " 
+                        "from __anext__: %.100s", 
+                        Py_TYPE(next_iter)->tp_name); 
+ 
+                    Py_DECREF(next_iter); 
+                    goto error; 
+                } else { 
+                    Py_DECREF(next_iter); 
+                } 
+            } 
+ 
+            PUSH(awaitable); 
+            PREDICT(LOAD_CONST); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(GET_AWAITABLE): {
             PREDICTED(GET_AWAITABLE);
-            PyObject *iterable = TOP();
-            PyObject *iter = _PyCoro_GetAwaitableIter(iterable);
-
-            if (iter == NULL) {
+            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,
-                                       _Py_OPCODE(next_instr[-2]));
-            }
-
-            Py_DECREF(iterable);
-
-            if (iter != NULL && PyCoro_CheckExact(iter)) {
-                PyObject *yf = _PyGen_yf((PyGenObject*)iter);
-                if (yf != NULL) {
-                    /* `iter` is a coroutine object that is being
-                       awaited, `yf` is a pointer to the current awaitable
-                       being awaited on. */
-                    Py_DECREF(yf);
-                    Py_CLEAR(iter);
+                                       _Py_OPCODE(next_instr[-2])); 
+            } 
+ 
+            Py_DECREF(iterable); 
+ 
+            if (iter != NULL && PyCoro_CheckExact(iter)) { 
+                PyObject *yf = _PyGen_yf((PyGenObject*)iter); 
+                if (yf != NULL) { 
+                    /* `iter` is a coroutine object that is being 
+                       awaited, `yf` is a pointer to the current awaitable 
+                       being awaited on. */ 
+                    Py_DECREF(yf); 
+                    Py_CLEAR(iter); 
                     _PyErr_SetString(tstate, PyExc_RuntimeError,
                                      "coroutine is being awaited already");
-                    /* The code below jumps to `error` if `iter` is NULL. */
-                }
-            }
-
-            SET_TOP(iter); /* Even if it's NULL */
-
-            if (iter == NULL) {
-                goto error;
-            }
-
-            PREDICT(LOAD_CONST);
-            DISPATCH();
-        }
-
+                    /* The code below jumps to `error` if `iter` is NULL. */ 
+                } 
+            } 
+ 
+            SET_TOP(iter); /* Even if it's NULL */ 
+ 
+            if (iter == NULL) { 
+                goto error; 
+            } 
+ 
+            PREDICT(LOAD_CONST); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(YIELD_FROM): {
-            PyObject *v = POP();
-            PyObject *receiver = TOP();
-            int err;
-            if (PyGen_CheckExact(receiver) || PyCoro_CheckExact(receiver)) {
-                retval = _PyGen_Send((PyGenObject *)receiver, v);
-            } else {
-                _Py_IDENTIFIER(send);
-                if (v == Py_None)
-                    retval = Py_TYPE(receiver)->tp_iternext(receiver);
-                else
+            PyObject *v = POP(); 
+            PyObject *receiver = TOP(); 
+            int err; 
+            if (PyGen_CheckExact(receiver) || PyCoro_CheckExact(receiver)) { 
+                retval = _PyGen_Send((PyGenObject *)receiver, v); 
+            } else { 
+                _Py_IDENTIFIER(send); 
+                if (v == Py_None) 
+                    retval = Py_TYPE(receiver)->tp_iternext(receiver); 
+                else 
                     retval = _PyObject_CallMethodIdOneArg(receiver, &PyId_send, v);
-            }
-            Py_DECREF(v);
-            if (retval == NULL) {
-                PyObject *val;
-                if (tstate->c_tracefunc != NULL
+            } 
+            Py_DECREF(v); 
+            if (retval == NULL) { 
+                PyObject *val; 
+                if (tstate->c_tracefunc != NULL 
                         && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
-                    call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f);
-                err = _PyGen_FetchStopIterationValue(&val);
-                if (err < 0)
-                    goto error;
-                Py_DECREF(receiver);
-                SET_TOP(val);
-                DISPATCH();
-            }
-            /* receiver remains on stack, retval is value to be yielded */
-            f->f_stacktop = stack_pointer;
-            /* and repeat... */
-            assert(f->f_lasti >= (int)sizeof(_Py_CODEUNIT));
-            f->f_lasti -= sizeof(_Py_CODEUNIT);
+                    call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f); 
+                err = _PyGen_FetchStopIterationValue(&val); 
+                if (err < 0) 
+                    goto error; 
+                Py_DECREF(receiver); 
+                SET_TOP(val); 
+                DISPATCH(); 
+            } 
+            /* receiver remains on stack, retval is value to be yielded */ 
+            f->f_stacktop = stack_pointer; 
+            /* and repeat... */ 
+            assert(f->f_lasti >= (int)sizeof(_Py_CODEUNIT)); 
+            f->f_lasti -= sizeof(_Py_CODEUNIT); 
             goto exiting;
-        }
-
+        } 
+ 
         case TARGET(YIELD_VALUE): {
-            retval = POP();
-
-            if (co->co_flags & CO_ASYNC_GENERATOR) {
-                PyObject *w = _PyAsyncGenValueWrapperNew(retval);
-                Py_DECREF(retval);
-                if (w == NULL) {
-                    retval = NULL;
-                    goto error;
-                }
-                retval = w;
-            }
-
-            f->f_stacktop = stack_pointer;
+            retval = POP(); 
+ 
+            if (co->co_flags & CO_ASYNC_GENERATOR) { 
+                PyObject *w = _PyAsyncGenValueWrapperNew(retval); 
+                Py_DECREF(retval); 
+                if (w == NULL) { 
+                    retval = NULL; 
+                    goto error; 
+                } 
+                retval = w; 
+            } 
+ 
+            f->f_stacktop = stack_pointer; 
             goto exiting;
-        }
-
+        } 
+ 
         case TARGET(POP_EXCEPT): {
             PyObject *type, *value, *traceback;
             _PyErr_StackItem *exc_info;
-            PyTryBlock *b = PyFrame_BlockPop(f);
-            if (b->b_type != EXCEPT_HANDLER) {
+            PyTryBlock *b = PyFrame_BlockPop(f); 
+            if (b->b_type != EXCEPT_HANDLER) { 
                 _PyErr_SetString(tstate, PyExc_SystemError,
                                  "popped block is not an except handler");
-                goto error;
-            }
+                goto error; 
+            } 
             assert(STACK_LEVEL() >= (b)->b_level + 3 &&
                    STACK_LEVEL() <= (b)->b_level + 4);
             exc_info = tstate->exc_info;
@@ -2266,15 +2266,15 @@ main_loop:
             Py_XDECREF(type);
             Py_XDECREF(value);
             Py_XDECREF(traceback);
-            DISPATCH();
-        }
-
+            DISPATCH(); 
+        } 
+ 
         case TARGET(POP_BLOCK): {
             PREDICTED(POP_BLOCK);
             PyFrame_BlockPop(f);
-            DISPATCH();
-        }
-
+            DISPATCH(); 
+        } 
+ 
         case TARGET(RERAISE): {
             PyObject *exc = POP();
             PyObject *val = POP();
@@ -2312,182 +2312,182 @@ main_loop:
         }
 
         case TARGET(LOAD_BUILD_CLASS): {
-            _Py_IDENTIFIER(__build_class__);
-
-            PyObject *bc;
-            if (PyDict_CheckExact(f->f_builtins)) {
+            _Py_IDENTIFIER(__build_class__); 
+ 
+            PyObject *bc; 
+            if (PyDict_CheckExact(f->f_builtins)) { 
                 bc = _PyDict_GetItemIdWithError(f->f_builtins, &PyId___build_class__);
-                if (bc == NULL) {
+                if (bc == NULL) { 
                     if (!_PyErr_Occurred(tstate)) {
                         _PyErr_SetString(tstate, PyExc_NameError,
                                          "__build_class__ not found");
                     }
-                    goto error;
-                }
-                Py_INCREF(bc);
-            }
-            else {
-                PyObject *build_class_str = _PyUnicode_FromId(&PyId___build_class__);
-                if (build_class_str == NULL)
-                    goto error;
-                bc = PyObject_GetItem(f->f_builtins, build_class_str);
-                if (bc == NULL) {
+                    goto error; 
+                } 
+                Py_INCREF(bc); 
+            } 
+            else { 
+                PyObject *build_class_str = _PyUnicode_FromId(&PyId___build_class__); 
+                if (build_class_str == NULL) 
+                    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");
-                    goto error;
-                }
-            }
-            PUSH(bc);
-            DISPATCH();
-        }
-
+                    goto error; 
+                } 
+            } 
+            PUSH(bc); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(STORE_NAME): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *v = POP();
-            PyObject *ns = f->f_locals;
-            int err;
-            if (ns == NULL) {
+            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);
-                Py_DECREF(v);
-                goto error;
-            }
-            if (PyDict_CheckExact(ns))
-                err = PyDict_SetItem(ns, name, v);
-            else
-                err = PyObject_SetItem(ns, name, v);
-            Py_DECREF(v);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+                Py_DECREF(v); 
+                goto error; 
+            } 
+            if (PyDict_CheckExact(ns)) 
+                err = PyDict_SetItem(ns, name, v); 
+            else 
+                err = PyObject_SetItem(ns, name, v); 
+            Py_DECREF(v); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DELETE_NAME): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *ns = f->f_locals;
-            int err;
-            if (ns == NULL) {
+            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);
-                goto error;
-            }
-            err = PyObject_DelItem(ns, name);
-            if (err != 0) {
+                goto error; 
+            } 
+            err = PyObject_DelItem(ns, name); 
+            if (err != 0) { 
                 format_exc_check_arg(tstate, PyExc_NameError,
-                                     NAME_ERROR_MSG,
-                                     name);
-                goto error;
-            }
-            DISPATCH();
-        }
-
+                                     NAME_ERROR_MSG, 
+                                     name); 
+                goto error; 
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(UNPACK_SEQUENCE): {
             PREDICTED(UNPACK_SEQUENCE);
-            PyObject *seq = POP(), *item, **items;
-            if (PyTuple_CheckExact(seq) &&
-                PyTuple_GET_SIZE(seq) == oparg) {
-                items = ((PyTupleObject *)seq)->ob_item;
-                while (oparg--) {
-                    item = items[oparg];
-                    Py_INCREF(item);
-                    PUSH(item);
-                }
-            } else if (PyList_CheckExact(seq) &&
-                       PyList_GET_SIZE(seq) == oparg) {
-                items = ((PyListObject *)seq)->ob_item;
-                while (oparg--) {
-                    item = items[oparg];
-                    Py_INCREF(item);
-                    PUSH(item);
-                }
+            PyObject *seq = POP(), *item, **items; 
+            if (PyTuple_CheckExact(seq) && 
+                PyTuple_GET_SIZE(seq) == oparg) { 
+                items = ((PyTupleObject *)seq)->ob_item; 
+                while (oparg--) { 
+                    item = items[oparg]; 
+                    Py_INCREF(item); 
+                    PUSH(item); 
+                } 
+            } else if (PyList_CheckExact(seq) && 
+                       PyList_GET_SIZE(seq) == oparg) { 
+                items = ((PyListObject *)seq)->ob_item; 
+                while (oparg--) { 
+                    item = items[oparg]; 
+                    Py_INCREF(item); 
+                    PUSH(item); 
+                } 
             } else if (unpack_iterable(tstate, seq, oparg, -1,
-                                       stack_pointer + oparg)) {
+                                       stack_pointer + oparg)) { 
                 STACK_GROW(oparg);
-            } else {
-                /* unpack_iterable() raised an exception */
-                Py_DECREF(seq);
-                goto error;
-            }
-            Py_DECREF(seq);
-            DISPATCH();
-        }
-
+            } else { 
+                /* unpack_iterable() raised an exception */ 
+                Py_DECREF(seq); 
+                goto error; 
+            } 
+            Py_DECREF(seq); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(UNPACK_EX): {
-            int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
-            PyObject *seq = POP();
-
+            int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8); 
+            PyObject *seq = POP(); 
+ 
             if (unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8,
-                                stack_pointer + totalargs)) {
-                stack_pointer += totalargs;
-            } else {
-                Py_DECREF(seq);
-                goto error;
-            }
-            Py_DECREF(seq);
-            DISPATCH();
-        }
-
+                                stack_pointer + totalargs)) { 
+                stack_pointer += totalargs; 
+            } else { 
+                Py_DECREF(seq); 
+                goto error; 
+            } 
+            Py_DECREF(seq); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(STORE_ATTR): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *owner = TOP();
-            PyObject *v = SECOND();
-            int err;
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *owner = TOP(); 
+            PyObject *v = SECOND(); 
+            int err; 
             STACK_SHRINK(2);
-            err = PyObject_SetAttr(owner, name, v);
-            Py_DECREF(v);
-            Py_DECREF(owner);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+            err = PyObject_SetAttr(owner, name, v); 
+            Py_DECREF(v); 
+            Py_DECREF(owner); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DELETE_ATTR): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *owner = POP();
-            int err;
-            err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
-            Py_DECREF(owner);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *owner = POP(); 
+            int err; 
+            err = PyObject_SetAttr(owner, name, (PyObject *)NULL); 
+            Py_DECREF(owner); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(STORE_GLOBAL): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *v = POP();
-            int err;
-            err = PyDict_SetItem(f->f_globals, name, v);
-            Py_DECREF(v);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *v = POP(); 
+            int err; 
+            err = PyDict_SetItem(f->f_globals, name, v); 
+            Py_DECREF(v); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DELETE_GLOBAL): {
-            PyObject *name = GETITEM(names, oparg);
-            int err;
-            err = PyDict_DelItem(f->f_globals, name);
-            if (err != 0) {
+            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);
                 }
-                goto error;
-            }
-            DISPATCH();
-        }
-
+                goto error; 
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_NAME): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *locals = f->f_locals;
-            PyObject *v;
-            if (locals == NULL) {
+            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);
-                goto error;
-            }
-            if (PyDict_CheckExact(locals)) {
+                goto error; 
+            } 
+            if (PyDict_CheckExact(locals)) { 
                 v = PyDict_GetItemWithError(locals, name);
                 if (v != NULL) {
                     Py_INCREF(v);
@@ -2495,16 +2495,16 @@ main_loop:
                 else if (_PyErr_Occurred(tstate)) {
                     goto error;
                 }
-            }
-            else {
-                v = PyObject_GetItem(locals, name);
-                if (v == NULL) {
+            } 
+            else { 
+                v = PyObject_GetItem(locals, name); 
+                if (v == NULL) { 
                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
-                        goto error;
+                        goto error; 
                     _PyErr_Clear(tstate);
-                }
-            }
-            if (v == NULL) {
+                } 
+            } 
+            if (v == NULL) { 
                 v = PyDict_GetItemWithError(f->f_globals, name);
                 if (v != NULL) {
                     Py_INCREF(v);
@@ -2513,41 +2513,41 @@ main_loop:
                     goto error;
                 }
                 else {
-                    if (PyDict_CheckExact(f->f_builtins)) {
+                    if (PyDict_CheckExact(f->f_builtins)) { 
                         v = PyDict_GetItemWithError(f->f_builtins, name);
-                        if (v == NULL) {
+                        if (v == NULL) { 
                             if (!_PyErr_Occurred(tstate)) {
                                 format_exc_check_arg(
                                         tstate, PyExc_NameError,
-                                        NAME_ERROR_MSG, name);
+                                        NAME_ERROR_MSG, name); 
                             }
-                            goto error;
-                        }
-                        Py_INCREF(v);
-                    }
-                    else {
-                        v = PyObject_GetItem(f->f_builtins, name);
-                        if (v == NULL) {
+                            goto error; 
+                        } 
+                        Py_INCREF(v); 
+                    } 
+                    else { 
+                        v = PyObject_GetItem(f->f_builtins, name); 
+                        if (v == NULL) { 
                             if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
-                                format_exc_check_arg(
+                                format_exc_check_arg( 
                                             tstate, PyExc_NameError,
-                                            NAME_ERROR_MSG, name);
+                                            NAME_ERROR_MSG, name); 
                             }
-                            goto error;
-                        }
-                    }
-                }
-            }
-            PUSH(v);
-            DISPATCH();
-        }
-
+                            goto error; 
+                        } 
+                    } 
+                } 
+            } 
+            PUSH(v); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_GLOBAL): {
             PyObject *name;
-            PyObject *v;
-            if (PyDict_CheckExact(f->f_globals)
-                && PyDict_CheckExact(f->f_builtins))
-            {
+            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;
@@ -2567,18 +2567,18 @@ main_loop:
                 }
 
                 name = GETITEM(names, oparg);
-                v = _PyDict_LoadGlobal((PyDictObject *)f->f_globals,
-                                       (PyDictObject *)f->f_builtins,
-                                       name);
-                if (v == NULL) {
-                    if (!_PyErr_OCCURRED()) {
-                        /* _PyDict_LoadGlobal() returns NULL without raising
-                         * an exception if the key doesn't exist */
+                v = _PyDict_LoadGlobal((PyDictObject *)f->f_globals, 
+                                       (PyDictObject *)f->f_builtins, 
+                                       name); 
+                if (v == NULL) { 
+                    if (!_PyErr_OCCURRED()) { 
+                        /* _PyDict_LoadGlobal() returns NULL without raising 
+                         * an exception if the key doesn't exist */ 
                         format_exc_check_arg(tstate, PyExc_NameError,
-                                             NAME_ERROR_MSG, name);
-                    }
-                    goto error;
-                }
+                                             NAME_ERROR_MSG, name); 
+                    } 
+                    goto error; 
+                } 
 
                 if (co_opcache != NULL) {
                     _PyOpcache_LoadGlobal *lg = &co_opcache->u.lg;
@@ -2598,78 +2598,78 @@ main_loop:
                     lg->ptr = v; /* borrowed */
                 }
 
-                Py_INCREF(v);
-            }
-            else {
-                /* Slow-path if globals or builtins is not a dict */
-
-                /* namespace 1: globals */
+                Py_INCREF(v); 
+            } 
+            else { 
+                /* Slow-path if globals or builtins is not a dict */ 
+ 
+                /* namespace 1: globals */ 
                 name = GETITEM(names, oparg);
-                v = PyObject_GetItem(f->f_globals, name);
-                if (v == NULL) {
+                v = PyObject_GetItem(f->f_globals, name); 
+                if (v == NULL) { 
                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
-                        goto error;
+                        goto error; 
                     }
                     _PyErr_Clear(tstate);
-
-                    /* namespace 2: builtins */
-                    v = PyObject_GetItem(f->f_builtins, name);
-                    if (v == NULL) {
+ 
+                    /* namespace 2: builtins */ 
+                    v = PyObject_GetItem(f->f_builtins, name); 
+                    if (v == NULL) { 
                         if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
-                            format_exc_check_arg(
+                            format_exc_check_arg( 
                                         tstate, PyExc_NameError,
-                                        NAME_ERROR_MSG, name);
+                                        NAME_ERROR_MSG, name); 
                         }
-                        goto error;
-                    }
-                }
-            }
-            PUSH(v);
-            DISPATCH();
-        }
-
+                        goto error; 
+                    } 
+                } 
+            } 
+            PUSH(v); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DELETE_FAST): {
-            PyObject *v = GETLOCAL(oparg);
-            if (v != NULL) {
-                SETLOCAL(oparg, NULL);
-                DISPATCH();
-            }
-            format_exc_check_arg(
+            PyObject *v = GETLOCAL(oparg); 
+            if (v != NULL) { 
+                SETLOCAL(oparg, NULL); 
+                DISPATCH(); 
+            } 
+            format_exc_check_arg( 
                 tstate, PyExc_UnboundLocalError,
-                UNBOUNDLOCAL_ERROR_MSG,
-                PyTuple_GetItem(co->co_varnames, oparg)
-                );
-            goto error;
-        }
-
+                UNBOUNDLOCAL_ERROR_MSG, 
+                PyTuple_GetItem(co->co_varnames, oparg) 
+                ); 
+            goto error; 
+        } 
+ 
         case TARGET(DELETE_DEREF): {
-            PyObject *cell = freevars[oparg];
-            PyObject *oldobj = PyCell_GET(cell);
-            if (oldobj != NULL) {
-                PyCell_SET(cell, NULL);
-                Py_DECREF(oldobj);
-                DISPATCH();
-            }
+            PyObject *cell = freevars[oparg]; 
+            PyObject *oldobj = PyCell_GET(cell); 
+            if (oldobj != NULL) { 
+                PyCell_SET(cell, NULL); 
+                Py_DECREF(oldobj); 
+                DISPATCH(); 
+            } 
             format_exc_unbound(tstate, co, oparg);
-            goto error;
-        }
-
+            goto error; 
+        } 
+ 
         case TARGET(LOAD_CLOSURE): {
-            PyObject *cell = freevars[oparg];
-            Py_INCREF(cell);
-            PUSH(cell);
-            DISPATCH();
-        }
-
+            PyObject *cell = freevars[oparg]; 
+            Py_INCREF(cell); 
+            PUSH(cell); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_CLASSDEREF): {
-            PyObject *name, *value, *locals = f->f_locals;
-            Py_ssize_t idx;
-            assert(locals);
-            assert(oparg >= PyTuple_GET_SIZE(co->co_cellvars));
-            idx = oparg - PyTuple_GET_SIZE(co->co_cellvars);
-            assert(idx >= 0 && idx < PyTuple_GET_SIZE(co->co_freevars));
-            name = PyTuple_GET_ITEM(co->co_freevars, idx);
-            if (PyDict_CheckExact(locals)) {
+            PyObject *name, *value, *locals = f->f_locals; 
+            Py_ssize_t idx; 
+            assert(locals); 
+            assert(oparg >= PyTuple_GET_SIZE(co->co_cellvars)); 
+            idx = oparg - PyTuple_GET_SIZE(co->co_cellvars); 
+            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);
@@ -2677,103 +2677,103 @@ main_loop:
                 else if (_PyErr_Occurred(tstate)) {
                     goto error;
                 }
-            }
-            else {
-                value = PyObject_GetItem(locals, name);
-                if (value == NULL) {
+            } 
+            else { 
+                value = PyObject_GetItem(locals, name); 
+                if (value == NULL) { 
                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
-                        goto error;
+                        goto error; 
                     }
                     _PyErr_Clear(tstate);
-                }
-            }
-            if (!value) {
-                PyObject *cell = freevars[oparg];
-                value = PyCell_GET(cell);
-                if (value == NULL) {
+                } 
+            } 
+            if (!value) { 
+                PyObject *cell = freevars[oparg]; 
+                value = PyCell_GET(cell); 
+                if (value == NULL) { 
                     format_exc_unbound(tstate, co, oparg);
-                    goto error;
-                }
-                Py_INCREF(value);
-            }
-            PUSH(value);
-            DISPATCH();
-        }
-
+                    goto error; 
+                } 
+                Py_INCREF(value); 
+            } 
+            PUSH(value); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_DEREF): {
-            PyObject *cell = freevars[oparg];
-            PyObject *value = PyCell_GET(cell);
-            if (value == NULL) {
+            PyObject *cell = freevars[oparg]; 
+            PyObject *value = PyCell_GET(cell); 
+            if (value == NULL) { 
                 format_exc_unbound(tstate, co, oparg);
-                goto error;
-            }
-            Py_INCREF(value);
-            PUSH(value);
-            DISPATCH();
-        }
-
+                goto error; 
+            } 
+            Py_INCREF(value); 
+            PUSH(value); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(STORE_DEREF): {
-            PyObject *v = POP();
-            PyObject *cell = freevars[oparg];
-            PyObject *oldobj = PyCell_GET(cell);
-            PyCell_SET(cell, v);
-            Py_XDECREF(oldobj);
-            DISPATCH();
-        }
-
+            PyObject *v = POP(); 
+            PyObject *cell = freevars[oparg]; 
+            PyObject *oldobj = PyCell_GET(cell); 
+            PyCell_SET(cell, v); 
+            Py_XDECREF(oldobj); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BUILD_STRING): {
-            PyObject *str;
-            PyObject *empty = PyUnicode_New(0, 0);
-            if (empty == NULL) {
-                goto error;
-            }
-            str = _PyUnicode_JoinArray(empty, stack_pointer - oparg, oparg);
-            Py_DECREF(empty);
-            if (str == NULL)
-                goto error;
-            while (--oparg >= 0) {
-                PyObject *item = POP();
-                Py_DECREF(item);
-            }
-            PUSH(str);
-            DISPATCH();
-        }
-
+            PyObject *str; 
+            PyObject *empty = PyUnicode_New(0, 0); 
+            if (empty == NULL) { 
+                goto error; 
+            } 
+            str = _PyUnicode_JoinArray(empty, stack_pointer - oparg, oparg); 
+            Py_DECREF(empty); 
+            if (str == NULL) 
+                goto error; 
+            while (--oparg >= 0) { 
+                PyObject *item = POP(); 
+                Py_DECREF(item); 
+            } 
+            PUSH(str); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BUILD_TUPLE): {
-            PyObject *tup = PyTuple_New(oparg);
-            if (tup == NULL)
-                goto error;
-            while (--oparg >= 0) {
-                PyObject *item = POP();
-                PyTuple_SET_ITEM(tup, oparg, item);
-            }
-            PUSH(tup);
-            DISPATCH();
-        }
-
+            PyObject *tup = PyTuple_New(oparg); 
+            if (tup == NULL) 
+                goto error; 
+            while (--oparg >= 0) { 
+                PyObject *item = POP(); 
+                PyTuple_SET_ITEM(tup, oparg, item); 
+            } 
+            PUSH(tup); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BUILD_LIST): {
-            PyObject *list =  PyList_New(oparg);
-            if (list == NULL)
-                goto error;
-            while (--oparg >= 0) {
-                PyObject *item = POP();
-                PyList_SET_ITEM(list, oparg, item);
-            }
-            PUSH(list);
-            DISPATCH();
-        }
-
+            PyObject *list =  PyList_New(oparg); 
+            if (list == NULL) 
+                goto error; 
+            while (--oparg >= 0) { 
+                PyObject *item = POP(); 
+                PyList_SET_ITEM(list, oparg, item); 
+            } 
+            PUSH(list); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LIST_TO_TUPLE): {
             PyObject *list = POP();
             PyObject *tuple = PyList_AsTuple(list);
             Py_DECREF(list);
             if (tuple == NULL) {
-                goto error;
+                goto error; 
             }
             PUSH(tuple);
             DISPATCH();
         }
-
+ 
         case TARGET(LIST_EXTEND): {
             PyObject *iterable = POP();
             PyObject *list = PEEK(oparg);
@@ -2786,15 +2786,15 @@ main_loop:
                     _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);
@@ -2802,147 +2802,147 @@ main_loop:
             Py_DECREF(iterable);
             if (err < 0) {
                 goto error;
-            }
-            DISPATCH();
-        }
-
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BUILD_SET): {
-            PyObject *set = PySet_New(NULL);
-            int err = 0;
-            int i;
-            if (set == NULL)
-                goto error;
-            for (i = oparg; i > 0; i--) {
-                PyObject *item = PEEK(i);
-                if (err == 0)
-                    err = PySet_Add(set, item);
-                Py_DECREF(item);
-            }
+            PyObject *set = PySet_New(NULL); 
+            int err = 0; 
+            int i; 
+            if (set == NULL) 
+                goto error; 
+            for (i = oparg; i > 0; i--) { 
+                PyObject *item = PEEK(i); 
+                if (err == 0) 
+                    err = PySet_Add(set, item); 
+                Py_DECREF(item); 
+            } 
             STACK_SHRINK(oparg);
-            if (err != 0) {
-                Py_DECREF(set);
-                goto error;
-            }
-            PUSH(set);
-            DISPATCH();
-        }
-
+            if (err != 0) { 
+                Py_DECREF(set); 
+                goto error; 
+            } 
+            PUSH(set); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BUILD_MAP): {
-            Py_ssize_t i;
-            PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg);
-            if (map == NULL)
-                goto error;
-            for (i = oparg; i > 0; i--) {
-                int err;
-                PyObject *key = PEEK(2*i);
-                PyObject *value = PEEK(2*i - 1);
-                err = PyDict_SetItem(map, key, value);
-                if (err != 0) {
-                    Py_DECREF(map);
-                    goto error;
-                }
-            }
-
-            while (oparg--) {
-                Py_DECREF(POP());
-                Py_DECREF(POP());
-            }
-            PUSH(map);
-            DISPATCH();
-        }
-
+            Py_ssize_t i; 
+            PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg); 
+            if (map == NULL) 
+                goto error; 
+            for (i = oparg; i > 0; i--) { 
+                int err; 
+                PyObject *key = PEEK(2*i); 
+                PyObject *value = PEEK(2*i - 1); 
+                err = PyDict_SetItem(map, key, value); 
+                if (err != 0) { 
+                    Py_DECREF(map); 
+                    goto error; 
+                } 
+            } 
+ 
+            while (oparg--) { 
+                Py_DECREF(POP()); 
+                Py_DECREF(POP()); 
+            } 
+            PUSH(map); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(SETUP_ANNOTATIONS): {
-            _Py_IDENTIFIER(__annotations__);
-            int err;
-            PyObject *ann_dict;
-            if (f->f_locals == NULL) {
+            _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");
-                goto error;
-            }
-            /* check if __annotations__ in locals()... */
-            if (PyDict_CheckExact(f->f_locals)) {
+                goto error; 
+            } 
+            /* check if __annotations__ in locals()... */ 
+            if (PyDict_CheckExact(f->f_locals)) { 
                 ann_dict = _PyDict_GetItemIdWithError(f->f_locals,
-                                             &PyId___annotations__);
-                if (ann_dict == NULL) {
+                                             &PyId___annotations__); 
+                if (ann_dict == NULL) { 
                     if (_PyErr_Occurred(tstate)) {
                         goto error;
                     }
-                    /* ...if not, create a new one */
-                    ann_dict = PyDict_New();
-                    if (ann_dict == NULL) {
-                        goto error;
-                    }
-                    err = _PyDict_SetItemId(f->f_locals,
-                                            &PyId___annotations__, ann_dict);
-                    Py_DECREF(ann_dict);
-                    if (err != 0) {
-                        goto error;
-                    }
-                }
-            }
-            else {
-                /* do the same if locals() is not a dict */
-                PyObject *ann_str = _PyUnicode_FromId(&PyId___annotations__);
-                if (ann_str == NULL) {
-                    goto error;
-                }
-                ann_dict = PyObject_GetItem(f->f_locals, ann_str);
-                if (ann_dict == NULL) {
+                    /* ...if not, create a new one */ 
+                    ann_dict = PyDict_New(); 
+                    if (ann_dict == NULL) { 
+                        goto error; 
+                    } 
+                    err = _PyDict_SetItemId(f->f_locals, 
+                                            &PyId___annotations__, ann_dict); 
+                    Py_DECREF(ann_dict); 
+                    if (err != 0) { 
+                        goto error; 
+                    } 
+                } 
+            } 
+            else { 
+                /* do the same if locals() is not a dict */ 
+                PyObject *ann_str = _PyUnicode_FromId(&PyId___annotations__); 
+                if (ann_str == NULL) { 
+                    goto error; 
+                } 
+                ann_dict = PyObject_GetItem(f->f_locals, ann_str); 
+                if (ann_dict == NULL) { 
                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
-                        goto error;
-                    }
+                        goto error; 
+                    } 
                     _PyErr_Clear(tstate);
-                    ann_dict = PyDict_New();
-                    if (ann_dict == NULL) {
-                        goto error;
-                    }
-                    err = PyObject_SetItem(f->f_locals, ann_str, ann_dict);
-                    Py_DECREF(ann_dict);
-                    if (err != 0) {
-                        goto error;
-                    }
-                }
-                else {
-                    Py_DECREF(ann_dict);
-                }
-            }
-            DISPATCH();
-        }
-
+                    ann_dict = PyDict_New(); 
+                    if (ann_dict == NULL) { 
+                        goto error; 
+                    } 
+                    err = PyObject_SetItem(f->f_locals, ann_str, ann_dict); 
+                    Py_DECREF(ann_dict); 
+                    if (err != 0) { 
+                        goto error; 
+                    } 
+                } 
+                else { 
+                    Py_DECREF(ann_dict); 
+                } 
+            } 
+            DISPATCH(); 
+        } 
+ 
         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) {
+            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");
-                goto error;
-            }
-            map = _PyDict_NewPresized((Py_ssize_t)oparg);
-            if (map == NULL) {
-                goto error;
-            }
-            for (i = oparg; i > 0; i--) {
-                int err;
-                PyObject *key = PyTuple_GET_ITEM(keys, oparg - i);
-                PyObject *value = PEEK(i + 1);
-                err = PyDict_SetItem(map, key, value);
-                if (err != 0) {
-                    Py_DECREF(map);
-                    goto error;
-                }
-            }
-
-            Py_DECREF(POP());
-            while (oparg--) {
-                Py_DECREF(POP());
-            }
-            PUSH(map);
-            DISPATCH();
-        }
-
+                goto error; 
+            } 
+            map = _PyDict_NewPresized((Py_ssize_t)oparg); 
+            if (map == NULL) { 
+                goto error; 
+            } 
+            for (i = oparg; i > 0; i--) { 
+                int err; 
+                PyObject *key = PyTuple_GET_ITEM(keys, oparg - i); 
+                PyObject *value = PEEK(i + 1); 
+                err = PyDict_SetItem(map, key, value); 
+                if (err != 0) { 
+                    Py_DECREF(map); 
+                    goto error; 
+                } 
+            } 
+ 
+            Py_DECREF(POP()); 
+            while (oparg--) { 
+                Py_DECREF(POP()); 
+            } 
+            PUSH(map); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DICT_UPDATE): {
             PyObject *update = POP();
             PyObject *dict = PEEK(oparg);
@@ -2953,12 +2953,12 @@ main_loop:
                                     Py_TYPE(update)->tp_name);
                 }
                 Py_DECREF(update);
-                goto error;
-            }
+                goto error; 
+            } 
             Py_DECREF(update);
-            DISPATCH();
-        }
-
+            DISPATCH(); 
+        } 
+ 
         case TARGET(DICT_MERGE): {
             PyObject *update = POP();
             PyObject *dict = PEEK(oparg);
@@ -2966,56 +2966,56 @@ main_loop:
             if (_PyDict_MergeEx(dict, update, 2) < 0) {
                 format_kwargs_error(tstate, PEEK(2 + oparg), update);
                 Py_DECREF(update);
-                goto error;
-            }
+                goto error; 
+            } 
             Py_DECREF(update);
             PREDICT(CALL_FUNCTION_EX);
-            DISPATCH();
-        }
-
+            DISPATCH(); 
+        } 
+ 
         case TARGET(MAP_ADD): {
             PyObject *value = TOP();
             PyObject *key = SECOND();
-            PyObject *map;
-            int err;
+            PyObject *map; 
+            int err; 
             STACK_SHRINK(2);
-            map = PEEK(oparg);                      /* dict */
-            assert(PyDict_CheckExact(map));
-            err = PyDict_SetItem(map, key, value);  /* map[key] = value */
-            Py_DECREF(value);
-            Py_DECREF(key);
-            if (err != 0)
-                goto error;
-            PREDICT(JUMP_ABSOLUTE);
-            DISPATCH();
-        }
-
+            map = PEEK(oparg);                      /* dict */ 
+            assert(PyDict_CheckExact(map)); 
+            err = PyDict_SetItem(map, key, value);  /* map[key] = value */ 
+            Py_DECREF(value); 
+            Py_DECREF(key); 
+            if (err != 0) 
+                goto error; 
+            PREDICT(JUMP_ABSOLUTE); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_ATTR): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *owner = TOP();
-            PyObject *res = PyObject_GetAttr(owner, name);
-            Py_DECREF(owner);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *owner = TOP(); 
+            PyObject *res = PyObject_GetAttr(owner, name); 
+            Py_DECREF(owner); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(COMPARE_OP): {
             assert(oparg <= Py_GE);
-            PyObject *right = POP();
-            PyObject *left = TOP();
+            PyObject *right = POP(); 
+            PyObject *left = TOP(); 
             PyObject *res = PyObject_RichCompare(left, right, oparg);
             SET_TOP(res);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            if (res == NULL)
-                goto error;
-            PREDICT(POP_JUMP_IF_FALSE);
-            PREDICT(POP_JUMP_IF_TRUE);
-            DISPATCH();
-        }
-
+            Py_DECREF(left); 
+            Py_DECREF(right); 
+            if (res == NULL) 
+                goto error; 
+            PREDICT(POP_JUMP_IF_FALSE); 
+            PREDICT(POP_JUMP_IF_TRUE); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(IS_OP): {
             PyObject *right = POP();
             PyObject *left = TOP();
@@ -3092,326 +3092,326 @@ main_loop:
         }
 
         case TARGET(IMPORT_NAME): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *fromlist = POP();
-            PyObject *level = TOP();
-            PyObject *res;
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *fromlist = POP(); 
+            PyObject *level = TOP(); 
+            PyObject *res; 
             res = import_name(tstate, f, name, fromlist, level);
-            Py_DECREF(level);
-            Py_DECREF(fromlist);
-            SET_TOP(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            Py_DECREF(level); 
+            Py_DECREF(fromlist); 
+            SET_TOP(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(IMPORT_STAR): {
-            PyObject *from = POP(), *locals;
-            int err;
-            if (PyFrame_FastToLocalsWithError(f) < 0) {
-                Py_DECREF(from);
-                goto error;
-            }
-
-            locals = f->f_locals;
-            if (locals == NULL) {
+            PyObject *from = POP(), *locals; 
+            int err; 
+            if (PyFrame_FastToLocalsWithError(f) < 0) { 
+                Py_DECREF(from); 
+                goto error; 
+            } 
+ 
+            locals = f->f_locals; 
+            if (locals == NULL) { 
                 _PyErr_SetString(tstate, PyExc_SystemError,
                                  "no locals found during 'import *'");
-                Py_DECREF(from);
-                goto error;
-            }
+                Py_DECREF(from); 
+                goto error; 
+            } 
             err = import_all_from(tstate, locals, from);
-            PyFrame_LocalsToFast(f, 0);
-            Py_DECREF(from);
-            if (err != 0)
-                goto error;
-            DISPATCH();
-        }
-
+            PyFrame_LocalsToFast(f, 0); 
+            Py_DECREF(from); 
+            if (err != 0) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(IMPORT_FROM): {
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *from = TOP();
-            PyObject *res;
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *from = TOP(); 
+            PyObject *res; 
             res = import_from(tstate, from, name);
-            PUSH(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PUSH(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(JUMP_FORWARD): {
-            JUMPBY(oparg);
-            FAST_DISPATCH();
-        }
-
+            JUMPBY(oparg); 
+            FAST_DISPATCH(); 
+        } 
+ 
         case TARGET(POP_JUMP_IF_FALSE): {
             PREDICTED(POP_JUMP_IF_FALSE);
-            PyObject *cond = POP();
-            int err;
-            if (cond == Py_True) {
-                Py_DECREF(cond);
-                FAST_DISPATCH();
-            }
-            if (cond == Py_False) {
-                Py_DECREF(cond);
-                JUMPTO(oparg);
-                FAST_DISPATCH();
-            }
-            err = PyObject_IsTrue(cond);
-            Py_DECREF(cond);
-            if (err > 0)
-                ;
-            else if (err == 0)
-                JUMPTO(oparg);
-            else
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *cond = POP(); 
+            int err; 
+            if (cond == Py_True) { 
+                Py_DECREF(cond); 
+                FAST_DISPATCH(); 
+            } 
+            if (cond == Py_False) { 
+                Py_DECREF(cond); 
+                JUMPTO(oparg); 
+                FAST_DISPATCH(); 
+            } 
+            err = PyObject_IsTrue(cond); 
+            Py_DECREF(cond); 
+            if (err > 0) 
+                ; 
+            else if (err == 0) 
+                JUMPTO(oparg); 
+            else 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(POP_JUMP_IF_TRUE): {
             PREDICTED(POP_JUMP_IF_TRUE);
-            PyObject *cond = POP();
-            int err;
-            if (cond == Py_False) {
-                Py_DECREF(cond);
-                FAST_DISPATCH();
-            }
-            if (cond == Py_True) {
-                Py_DECREF(cond);
-                JUMPTO(oparg);
-                FAST_DISPATCH();
-            }
-            err = PyObject_IsTrue(cond);
-            Py_DECREF(cond);
-            if (err > 0) {
-                JUMPTO(oparg);
-            }
-            else if (err == 0)
-                ;
-            else
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *cond = POP(); 
+            int err; 
+            if (cond == Py_False) { 
+                Py_DECREF(cond); 
+                FAST_DISPATCH(); 
+            } 
+            if (cond == Py_True) { 
+                Py_DECREF(cond); 
+                JUMPTO(oparg); 
+                FAST_DISPATCH(); 
+            } 
+            err = PyObject_IsTrue(cond); 
+            Py_DECREF(cond); 
+            if (err > 0) { 
+                JUMPTO(oparg); 
+            } 
+            else if (err == 0) 
+                ; 
+            else 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(JUMP_IF_FALSE_OR_POP): {
-            PyObject *cond = TOP();
-            int err;
-            if (cond == Py_True) {
+            PyObject *cond = TOP(); 
+            int err; 
+            if (cond == Py_True) { 
                 STACK_SHRINK(1);
-                Py_DECREF(cond);
-                FAST_DISPATCH();
-            }
-            if (cond == Py_False) {
-                JUMPTO(oparg);
-                FAST_DISPATCH();
-            }
-            err = PyObject_IsTrue(cond);
-            if (err > 0) {
+                Py_DECREF(cond); 
+                FAST_DISPATCH(); 
+            } 
+            if (cond == Py_False) { 
+                JUMPTO(oparg); 
+                FAST_DISPATCH(); 
+            } 
+            err = PyObject_IsTrue(cond); 
+            if (err > 0) { 
                 STACK_SHRINK(1);
-                Py_DECREF(cond);
-            }
-            else if (err == 0)
-                JUMPTO(oparg);
-            else
-                goto error;
-            DISPATCH();
-        }
-
+                Py_DECREF(cond); 
+            } 
+            else if (err == 0) 
+                JUMPTO(oparg); 
+            else 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(JUMP_IF_TRUE_OR_POP): {
-            PyObject *cond = TOP();
-            int err;
-            if (cond == Py_False) {
+            PyObject *cond = TOP(); 
+            int err; 
+            if (cond == Py_False) { 
                 STACK_SHRINK(1);
-                Py_DECREF(cond);
-                FAST_DISPATCH();
-            }
-            if (cond == Py_True) {
-                JUMPTO(oparg);
-                FAST_DISPATCH();
-            }
-            err = PyObject_IsTrue(cond);
-            if (err > 0) {
-                JUMPTO(oparg);
-            }
-            else if (err == 0) {
+                Py_DECREF(cond); 
+                FAST_DISPATCH(); 
+            } 
+            if (cond == Py_True) { 
+                JUMPTO(oparg); 
+                FAST_DISPATCH(); 
+            } 
+            err = PyObject_IsTrue(cond); 
+            if (err > 0) { 
+                JUMPTO(oparg); 
+            } 
+            else if (err == 0) { 
                 STACK_SHRINK(1);
-                Py_DECREF(cond);
-            }
-            else
-                goto error;
-            DISPATCH();
-        }
-
+                Py_DECREF(cond); 
+            } 
+            else 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(JUMP_ABSOLUTE): {
             PREDICTED(JUMP_ABSOLUTE);
-            JUMPTO(oparg);
-#if FAST_LOOPS
-            /* Enabling this path speeds-up all while and for-loops by bypassing
-               the per-loop checks for signals.  By default, this should be turned-off
-               because it prevents detection of a control-break in tight loops like
-               "while 1: pass".  Compile with this option turned-on when you need
-               the speed-up and do not need break checking inside tight loops (ones
-               that contain only instructions ending with FAST_DISPATCH).
-            */
-            FAST_DISPATCH();
-#else
-            DISPATCH();
-#endif
-        }
-
+            JUMPTO(oparg); 
+#if FAST_LOOPS 
+            /* Enabling this path speeds-up all while and for-loops by bypassing 
+               the per-loop checks for signals.  By default, this should be turned-off 
+               because it prevents detection of a control-break in tight loops like 
+               "while 1: pass".  Compile with this option turned-on when you need 
+               the speed-up and do not need break checking inside tight loops (ones 
+               that contain only instructions ending with FAST_DISPATCH). 
+            */ 
+            FAST_DISPATCH(); 
+#else 
+            DISPATCH(); 
+#endif 
+        } 
+ 
         case TARGET(GET_ITER): {
-            /* before: [obj]; after [getiter(obj)] */
-            PyObject *iterable = TOP();
-            PyObject *iter = PyObject_GetIter(iterable);
-            Py_DECREF(iterable);
-            SET_TOP(iter);
-            if (iter == NULL)
-                goto error;
-            PREDICT(FOR_ITER);
-            PREDICT(CALL_FUNCTION);
-            DISPATCH();
-        }
-
+            /* before: [obj]; after [getiter(obj)] */ 
+            PyObject *iterable = TOP(); 
+            PyObject *iter = PyObject_GetIter(iterable); 
+            Py_DECREF(iterable); 
+            SET_TOP(iter); 
+            if (iter == NULL) 
+                goto error; 
+            PREDICT(FOR_ITER); 
+            PREDICT(CALL_FUNCTION); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(GET_YIELD_FROM_ITER): {
-            /* before: [obj]; after [getiter(obj)] */
-            PyObject *iterable = TOP();
-            PyObject *iter;
-            if (PyCoro_CheckExact(iterable)) {
-                /* `iterable` is a coroutine */
-                if (!(co->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
-                    /* and it is used in a 'yield from' expression of a
-                       regular generator. */
-                    Py_DECREF(iterable);
-                    SET_TOP(NULL);
+            /* before: [obj]; after [getiter(obj)] */ 
+            PyObject *iterable = TOP(); 
+            PyObject *iter; 
+            if (PyCoro_CheckExact(iterable)) { 
+                /* `iterable` is a coroutine */ 
+                if (!(co->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { 
+                    /* and it is used in a 'yield from' expression of a 
+                       regular generator. */ 
+                    Py_DECREF(iterable); 
+                    SET_TOP(NULL); 
                     _PyErr_SetString(tstate, PyExc_TypeError,
                                      "cannot 'yield from' a coroutine object "
                                      "in a non-coroutine generator");
-                    goto error;
-                }
-            }
-            else if (!PyGen_CheckExact(iterable)) {
-                /* `iterable` is not a generator. */
-                iter = PyObject_GetIter(iterable);
-                Py_DECREF(iterable);
-                SET_TOP(iter);
-                if (iter == NULL)
-                    goto error;
-            }
-            PREDICT(LOAD_CONST);
-            DISPATCH();
-        }
-
+                    goto error; 
+                } 
+            } 
+            else if (!PyGen_CheckExact(iterable)) { 
+                /* `iterable` is not a generator. */ 
+                iter = PyObject_GetIter(iterable); 
+                Py_DECREF(iterable); 
+                SET_TOP(iter); 
+                if (iter == NULL) 
+                    goto error; 
+            } 
+            PREDICT(LOAD_CONST); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(FOR_ITER): {
             PREDICTED(FOR_ITER);
-            /* before: [iter]; after: [iter, iter()] *or* [] */
-            PyObject *iter = TOP();
+            /* before: [iter]; after: [iter, iter()] *or* [] */ 
+            PyObject *iter = TOP(); 
             PyObject *next = (*Py_TYPE(iter)->tp_iternext)(iter);
-            if (next != NULL) {
-                PUSH(next);
-                PREDICT(STORE_FAST);
-                PREDICT(UNPACK_SEQUENCE);
-                DISPATCH();
-            }
+            if (next != NULL) { 
+                PUSH(next); 
+                PREDICT(STORE_FAST); 
+                PREDICT(UNPACK_SEQUENCE); 
+                DISPATCH(); 
+            } 
             if (_PyErr_Occurred(tstate)) {
                 if (!_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) {
-                    goto error;
+                    goto error; 
                 }
                 else if (tstate->c_tracefunc != NULL) {
-                    call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f);
+                    call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f); 
                 }
                 _PyErr_Clear(tstate);
-            }
-            /* iterator ended normally */
+            } 
+            /* iterator ended normally */ 
             STACK_SHRINK(1);
-            Py_DECREF(iter);
-            JUMPBY(oparg);
-            PREDICT(POP_BLOCK);
-            DISPATCH();
-        }
-
+            Py_DECREF(iter); 
+            JUMPBY(oparg); 
+            PREDICT(POP_BLOCK); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(SETUP_FINALLY): {
             PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg,
-                               STACK_LEVEL());
-            DISPATCH();
-        }
-
+                               STACK_LEVEL()); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BEFORE_ASYNC_WITH): {
             _Py_IDENTIFIER(__aenter__);
-            _Py_IDENTIFIER(__aexit__);
-            PyObject *mgr = TOP();
+            _Py_IDENTIFIER(__aexit__); 
+            PyObject *mgr = TOP(); 
             PyObject *enter = special_lookup(tstate, mgr, &PyId___aenter__);
-            PyObject *res;
+            PyObject *res; 
             if (enter == NULL) {
-                goto error;
+                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);
-            Py_DECREF(enter);
-            if (res == NULL)
-                goto error;
-            PUSH(res);
-            PREDICT(GET_AWAITABLE);
-            DISPATCH();
-        }
-
+            SET_TOP(exit); 
+            Py_DECREF(mgr); 
+            res = _PyObject_CallNoArg(enter); 
+            Py_DECREF(enter); 
+            if (res == NULL) 
+                goto error; 
+            PUSH(res); 
+            PREDICT(GET_AWAITABLE); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(SETUP_ASYNC_WITH): {
-            PyObject *res = POP();
-            /* Setup the finally block before pushing the result
-               of __aenter__ on the stack. */
-            PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg,
-                               STACK_LEVEL());
-            PUSH(res);
-            DISPATCH();
-        }
-
+            PyObject *res = POP(); 
+            /* Setup the finally block before pushing the result 
+               of __aenter__ on the stack. */ 
+            PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg, 
+                               STACK_LEVEL()); 
+            PUSH(res); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(SETUP_WITH): {
             _Py_IDENTIFIER(__enter__);
-            _Py_IDENTIFIER(__exit__);
-            PyObject *mgr = TOP();
+            _Py_IDENTIFIER(__exit__); 
+            PyObject *mgr = TOP(); 
             PyObject *enter = special_lookup(tstate, mgr, &PyId___enter__);
-            PyObject *res;
+            PyObject *res; 
             if (enter == NULL) {
-                goto error;
+                goto error; 
             }
             PyObject *exit = special_lookup(tstate, mgr, &PyId___exit__);
-            if (exit == NULL) {
-                Py_DECREF(enter);
-                goto error;
-            }
-            SET_TOP(exit);
-            Py_DECREF(mgr);
-            res = _PyObject_CallNoArg(enter);
-            Py_DECREF(enter);
-            if (res == NULL)
-                goto error;
-            /* Setup the finally block before pushing the result
-               of __enter__ on the stack. */
-            PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg,
-                               STACK_LEVEL());
-
-            PUSH(res);
-            DISPATCH();
-        }
-
+            if (exit == NULL) { 
+                Py_DECREF(enter); 
+                goto error; 
+            } 
+            SET_TOP(exit); 
+            Py_DECREF(mgr); 
+            res = _PyObject_CallNoArg(enter); 
+            Py_DECREF(enter); 
+            if (res == NULL) 
+                goto error; 
+            /* Setup the finally block before pushing the result 
+               of __enter__ on the stack. */ 
+            PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg, 
+                               STACK_LEVEL()); 
+ 
+            PUSH(res); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(WITH_EXCEPT_START): {
             /* At the top of the stack are 7 values:
-               - (TOP, SECOND, THIRD) = exc_info()
+               - (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.
-            */
-            PyObject *exit_func;
-            PyObject *exc, *val, *tb, *res;
-
-            exc = TOP();
+            */ 
+            PyObject *exit_func; 
+            PyObject *exc, *val, *tb, *res; 
+ 
+            exc = TOP(); 
             val = SECOND();
             tb = THIRD();
             assert(exc != Py_None);
@@ -3420,379 +3420,379 @@ main_loop:
             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;
-
-            PUSH(res);
-            DISPATCH();
-        }
-
+            if (res == NULL) 
+                goto error; 
+ 
+            PUSH(res); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(LOAD_METHOD): {
             /* Designed to work in tandem with CALL_METHOD. */
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *obj = TOP();
-            PyObject *meth = NULL;
-
-            int meth_found = _PyObject_GetMethod(obj, name, &meth);
-
-            if (meth == NULL) {
-                /* Most likely attribute wasn't found. */
-                goto error;
-            }
-
-            if (meth_found) {
-                /* We can bypass temporary bound method object.
-                   meth is unbound method and obj is self.
-
-                   meth | self | arg1 | ... | argN
-                 */
-                SET_TOP(meth);
-                PUSH(obj);  // self
-            }
-            else {
-                /* meth is not an unbound method (but a regular attr, or
-                   something was returned by a descriptor protocol).  Set
-                   the second element of the stack to NULL, to signal
-                   CALL_METHOD that it's not a method call.
-
-                   NULL | meth | arg1 | ... | argN
-                */
-                SET_TOP(NULL);
-                Py_DECREF(obj);
-                PUSH(meth);
-            }
-            DISPATCH();
-        }
-
+            PyObject *name = GETITEM(names, oparg); 
+            PyObject *obj = TOP(); 
+            PyObject *meth = NULL; 
+ 
+            int meth_found = _PyObject_GetMethod(obj, name, &meth); 
+ 
+            if (meth == NULL) { 
+                /* Most likely attribute wasn't found. */ 
+                goto error; 
+            } 
+ 
+            if (meth_found) { 
+                /* We can bypass temporary bound method object. 
+                   meth is unbound method and obj is self. 
+ 
+                   meth | self | arg1 | ... | argN 
+                 */ 
+                SET_TOP(meth); 
+                PUSH(obj);  // self 
+            } 
+            else { 
+                /* meth is not an unbound method (but a regular attr, or 
+                   something was returned by a descriptor protocol).  Set 
+                   the second element of the stack to NULL, to signal 
+                   CALL_METHOD that it's not a method call. 
+ 
+                   NULL | meth | arg1 | ... | argN 
+                */ 
+                SET_TOP(NULL); 
+                Py_DECREF(obj); 
+                PUSH(meth); 
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(CALL_METHOD): {
-            /* Designed to work in tamdem with LOAD_METHOD. */
-            PyObject **sp, *res, *meth;
-
-            sp = stack_pointer;
-
-            meth = PEEK(oparg + 2);
-            if (meth == NULL) {
-                /* `meth` is NULL when LOAD_METHOD thinks that it's not
-                   a method call.
-
-                   Stack layout:
-
-                       ... | NULL | callable | arg1 | ... | argN
-                                                            ^- TOP()
-                                               ^- (-oparg)
-                                    ^- (-oparg-1)
-                             ^- (-oparg-2)
-
-                   `callable` will be POPed by call_function.
-                   NULL will will be POPed manually later.
-                */
+            /* Designed to work in tamdem with LOAD_METHOD. */ 
+            PyObject **sp, *res, *meth; 
+ 
+            sp = stack_pointer; 
+ 
+            meth = PEEK(oparg + 2); 
+            if (meth == NULL) { 
+                /* `meth` is NULL when LOAD_METHOD thinks that it's not 
+                   a method call. 
+ 
+                   Stack layout: 
+ 
+                       ... | NULL | callable | arg1 | ... | argN 
+                                                            ^- TOP() 
+                                               ^- (-oparg) 
+                                    ^- (-oparg-1) 
+                             ^- (-oparg-2) 
+ 
+                   `callable` will be POPed by call_function. 
+                   NULL will will be POPed manually later. 
+                */ 
                 res = call_function(tstate, &sp, oparg, NULL);
-                stack_pointer = sp;
-                (void)POP(); /* POP the NULL. */
-            }
-            else {
-                /* This is a method call.  Stack layout:
-
-                     ... | method | self | arg1 | ... | argN
-                                                        ^- TOP()
-                                           ^- (-oparg)
-                                    ^- (-oparg-1)
-                           ^- (-oparg-2)
-
-                  `self` and `method` will be POPed by call_function.
-                  We'll be passing `oparg + 1` to call_function, to
-                  make it accept the `self` as a first argument.
-                */
+                stack_pointer = sp; 
+                (void)POP(); /* POP the NULL. */ 
+            } 
+            else { 
+                /* This is a method call.  Stack layout: 
+ 
+                     ... | method | self | arg1 | ... | argN 
+                                                        ^- TOP() 
+                                           ^- (-oparg) 
+                                    ^- (-oparg-1) 
+                           ^- (-oparg-2) 
+ 
+                  `self` and `method` will be POPed by call_function. 
+                  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);
-                stack_pointer = sp;
-            }
-
-            PUSH(res);
-            if (res == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+                stack_pointer = sp; 
+            } 
+ 
+            PUSH(res); 
+            if (res == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(CALL_FUNCTION): {
             PREDICTED(CALL_FUNCTION);
-            PyObject **sp, *res;
-            sp = stack_pointer;
+            PyObject **sp, *res; 
+            sp = stack_pointer; 
             res = call_function(tstate, &sp, oparg, NULL);
-            stack_pointer = sp;
-            PUSH(res);
-            if (res == NULL) {
-                goto error;
-            }
-            DISPATCH();
-        }
-
+            stack_pointer = sp; 
+            PUSH(res); 
+            if (res == NULL) { 
+                goto error; 
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(CALL_FUNCTION_KW): {
-            PyObject **sp, *res, *names;
-
-            names = POP();
+            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 */
-            sp = stack_pointer;
+            sp = stack_pointer; 
             res = call_function(tstate, &sp, oparg, names);
-            stack_pointer = sp;
-            PUSH(res);
-            Py_DECREF(names);
-
-            if (res == NULL) {
-                goto error;
-            }
-            DISPATCH();
-        }
-
+            stack_pointer = sp; 
+            PUSH(res); 
+            Py_DECREF(names); 
+ 
+            if (res == NULL) { 
+                goto error; 
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(CALL_FUNCTION_EX): {
             PREDICTED(CALL_FUNCTION_EX);
-            PyObject *func, *callargs, *kwargs = NULL, *result;
-            if (oparg & 0x01) {
-                kwargs = POP();
-                if (!PyDict_CheckExact(kwargs)) {
-                    PyObject *d = PyDict_New();
-                    if (d == NULL)
-                        goto error;
+            PyObject *func, *callargs, *kwargs = NULL, *result; 
+            if (oparg & 0x01) { 
+                kwargs = POP(); 
+                if (!PyDict_CheckExact(kwargs)) { 
+                    PyObject *d = PyDict_New(); 
+                    if (d == NULL) 
+                        goto error; 
                     if (_PyDict_MergeEx(d, kwargs, 2) < 0) {
-                        Py_DECREF(d);
+                        Py_DECREF(d); 
                         format_kwargs_error(tstate, SECOND(), kwargs);
-                        Py_DECREF(kwargs);
-                        goto error;
-                    }
-                    Py_DECREF(kwargs);
-                    kwargs = d;
-                }
-                assert(PyDict_CheckExact(kwargs));
-            }
-            callargs = POP();
-            func = TOP();
-            if (!PyTuple_CheckExact(callargs)) {
+                        Py_DECREF(kwargs); 
+                        goto error; 
+                    } 
+                    Py_DECREF(kwargs); 
+                    kwargs = d; 
+                } 
+                assert(PyDict_CheckExact(kwargs)); 
+            } 
+            callargs = POP(); 
+            func = TOP(); 
+            if (!PyTuple_CheckExact(callargs)) { 
                 if (check_args_iterable(tstate, func, callargs) < 0) {
-                    Py_DECREF(callargs);
-                    goto error;
-                }
-                Py_SETREF(callargs, PySequence_Tuple(callargs));
-                if (callargs == NULL) {
-                    goto error;
-                }
-            }
-            assert(PyTuple_CheckExact(callargs));
-
+                    Py_DECREF(callargs); 
+                    goto error; 
+                } 
+                Py_SETREF(callargs, PySequence_Tuple(callargs)); 
+                if (callargs == NULL) { 
+                    goto error; 
+                } 
+            } 
+            assert(PyTuple_CheckExact(callargs)); 
+ 
             result = do_call_core(tstate, func, callargs, kwargs);
-            Py_DECREF(func);
-            Py_DECREF(callargs);
-            Py_XDECREF(kwargs);
-
-            SET_TOP(result);
-            if (result == NULL) {
-                goto error;
-            }
-            DISPATCH();
-        }
-
+            Py_DECREF(func); 
+            Py_DECREF(callargs); 
+            Py_XDECREF(kwargs); 
+ 
+            SET_TOP(result); 
+            if (result == NULL) { 
+                goto error; 
+            } 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(MAKE_FUNCTION): {
-            PyObject *qualname = POP();
-            PyObject *codeobj = POP();
-            PyFunctionObject *func = (PyFunctionObject *)
-                PyFunction_NewWithQualName(codeobj, f->f_globals, qualname);
-
-            Py_DECREF(codeobj);
-            Py_DECREF(qualname);
-            if (func == NULL) {
-                goto error;
-            }
-
-            if (oparg & 0x08) {
-                assert(PyTuple_CheckExact(TOP()));
-                func ->func_closure = POP();
-            }
-            if (oparg & 0x04) {
-                assert(PyDict_CheckExact(TOP()));
-                func->func_annotations = POP();
-            }
-            if (oparg & 0x02) {
-                assert(PyDict_CheckExact(TOP()));
-                func->func_kwdefaults = POP();
-            }
-            if (oparg & 0x01) {
-                assert(PyTuple_CheckExact(TOP()));
-                func->func_defaults = POP();
-            }
-
-            PUSH((PyObject *)func);
-            DISPATCH();
-        }
-
+            PyObject *qualname = POP(); 
+            PyObject *codeobj = POP(); 
+            PyFunctionObject *func = (PyFunctionObject *) 
+                PyFunction_NewWithQualName(codeobj, f->f_globals, qualname); 
+ 
+            Py_DECREF(codeobj); 
+            Py_DECREF(qualname); 
+            if (func == NULL) { 
+                goto error; 
+            } 
+ 
+            if (oparg & 0x08) { 
+                assert(PyTuple_CheckExact(TOP())); 
+                func ->func_closure = POP(); 
+            } 
+            if (oparg & 0x04) { 
+                assert(PyDict_CheckExact(TOP())); 
+                func->func_annotations = POP(); 
+            } 
+            if (oparg & 0x02) { 
+                assert(PyDict_CheckExact(TOP())); 
+                func->func_kwdefaults = POP(); 
+            } 
+            if (oparg & 0x01) { 
+                assert(PyTuple_CheckExact(TOP())); 
+                func->func_defaults = POP(); 
+            } 
+ 
+            PUSH((PyObject *)func); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(BUILD_SLICE): {
-            PyObject *start, *stop, *step, *slice;
-            if (oparg == 3)
-                step = POP();
-            else
-                step = NULL;
-            stop = POP();
-            start = TOP();
-            slice = PySlice_New(start, stop, step);
-            Py_DECREF(start);
-            Py_DECREF(stop);
-            Py_XDECREF(step);
-            SET_TOP(slice);
-            if (slice == NULL)
-                goto error;
-            DISPATCH();
-        }
-
+            PyObject *start, *stop, *step, *slice; 
+            if (oparg == 3) 
+                step = POP(); 
+            else 
+                step = NULL; 
+            stop = POP(); 
+            start = TOP(); 
+            slice = PySlice_New(start, stop, step); 
+            Py_DECREF(start); 
+            Py_DECREF(stop); 
+            Py_XDECREF(step); 
+            SET_TOP(slice); 
+            if (slice == NULL) 
+                goto error; 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(FORMAT_VALUE): {
-            /* Handles f-string value formatting. */
-            PyObject *result;
-            PyObject *fmt_spec;
-            PyObject *value;
-            PyObject *(*conv_fn)(PyObject *);
-            int which_conversion = oparg & FVC_MASK;
-            int have_fmt_spec = (oparg & FVS_MASK) == FVS_HAVE_SPEC;
-
-            fmt_spec = have_fmt_spec ? POP() : NULL;
-            value = POP();
-
-            /* See if any conversion is specified. */
-            switch (which_conversion) {
+            /* Handles f-string value formatting. */ 
+            PyObject *result; 
+            PyObject *fmt_spec; 
+            PyObject *value; 
+            PyObject *(*conv_fn)(PyObject *); 
+            int which_conversion = oparg & FVC_MASK; 
+            int have_fmt_spec = (oparg & FVS_MASK) == FVS_HAVE_SPEC; 
+ 
+            fmt_spec = have_fmt_spec ? POP() : NULL; 
+            value = POP(); 
+ 
+            /* See if any conversion is specified. */ 
+            switch (which_conversion) { 
             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;
+            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;
-            }
-
-            /* If there's a conversion function, call it and replace
-               value with that result. Otherwise, just use value,
-               without conversion. */
-            if (conv_fn != NULL) {
-                result = conv_fn(value);
-                Py_DECREF(value);
-                if (result == NULL) {
-                    Py_XDECREF(fmt_spec);
-                    goto error;
-                }
-                value = result;
-            }
-
-            /* If value is a unicode object, and there's no fmt_spec,
-               then we know the result of format(value) is value
-               itself. In that case, skip calling format(). I plan to
-               move this optimization in to PyObject_Format()
-               itself. */
-            if (PyUnicode_CheckExact(value) && fmt_spec == NULL) {
-                /* Do nothing, just transfer ownership to result. */
-                result = value;
-            } else {
-                /* Actually call format(). */
-                result = PyObject_Format(value, fmt_spec);
-                Py_DECREF(value);
-                Py_XDECREF(fmt_spec);
-                if (result == NULL) {
-                    goto error;
-                }
-            }
-
-            PUSH(result);
-            DISPATCH();
-        }
-
+            } 
+ 
+            /* If there's a conversion function, call it and replace 
+               value with that result. Otherwise, just use value, 
+               without conversion. */ 
+            if (conv_fn != NULL) { 
+                result = conv_fn(value); 
+                Py_DECREF(value); 
+                if (result == NULL) { 
+                    Py_XDECREF(fmt_spec); 
+                    goto error; 
+                } 
+                value = result; 
+            } 
+ 
+            /* If value is a unicode object, and there's no fmt_spec, 
+               then we know the result of format(value) is value 
+               itself. In that case, skip calling format(). I plan to 
+               move this optimization in to PyObject_Format() 
+               itself. */ 
+            if (PyUnicode_CheckExact(value) && fmt_spec == NULL) { 
+                /* Do nothing, just transfer ownership to result. */ 
+                result = value; 
+            } else { 
+                /* Actually call format(). */ 
+                result = PyObject_Format(value, fmt_spec); 
+                Py_DECREF(value); 
+                Py_XDECREF(fmt_spec); 
+                if (result == NULL) { 
+                    goto error; 
+                } 
+            } 
+ 
+            PUSH(result); 
+            DISPATCH(); 
+        } 
+ 
         case TARGET(EXTENDED_ARG): {
-            int oldoparg = oparg;
-            NEXTOPARG();
-            oparg |= oldoparg << 8;
-            goto dispatch_opcode;
-        }
-
-
-#if USE_COMPUTED_GOTOS
-        _unknown_opcode:
-#endif
-        default:
-            fprintf(stderr,
-                "XXX lineno: %d, opcode: %d\n",
-                PyFrame_GetLineNumber(f),
-                opcode);
+            int oldoparg = oparg; 
+            NEXTOPARG(); 
+            oparg |= oldoparg << 8; 
+            goto dispatch_opcode; 
+        } 
+ 
+ 
+#if USE_COMPUTED_GOTOS 
+        _unknown_opcode: 
+#endif 
+        default: 
+            fprintf(stderr, 
+                "XXX lineno: %d, opcode: %d\n", 
+                PyFrame_GetLineNumber(f), 
+                opcode); 
             _PyErr_SetString(tstate, PyExc_SystemError, "unknown opcode");
-            goto error;
-
-        } /* switch */
-
-        /* This should never be reached. Every opcode should end with DISPATCH()
-           or goto error. */
-        Py_UNREACHABLE();
-
-error:
-        /* Double-check exception status. */
-#ifdef NDEBUG
+            goto error; 
+ 
+        } /* switch */ 
+ 
+        /* This should never be reached. Every opcode should end with DISPATCH() 
+           or goto error. */ 
+        Py_UNREACHABLE(); 
+ 
+error: 
+        /* Double-check exception status. */ 
+#ifdef NDEBUG 
         if (!_PyErr_Occurred(tstate)) {
             _PyErr_SetString(tstate, PyExc_SystemError,
                              "error return without exception set");
         }
-#else
+#else 
         assert(_PyErr_Occurred(tstate));
-#endif
-
-        /* Log traceback info. */
-        PyTraceBack_Here(f);
-
-        if (tstate->c_tracefunc != NULL)
-            call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj,
-                           tstate, f);
-
+#endif 
+ 
+        /* Log traceback info. */ 
+        PyTraceBack_Here(f); 
+ 
+        if (tstate->c_tracefunc != NULL) 
+            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];
-
-            if (b->b_type == EXCEPT_HANDLER) {
-                UNWIND_EXCEPT_HANDLER(b);
-                continue;
-            }
-            UNWIND_BLOCK(b);
+ 
+            if (b->b_type == EXCEPT_HANDLER) { 
+                UNWIND_EXCEPT_HANDLER(b); 
+                continue; 
+            } 
+            UNWIND_BLOCK(b); 
             if (b->b_type == SETUP_FINALLY) {
-                PyObject *exc, *val, *tb;
-                int handler = b->b_handler;
-                _PyErr_StackItem *exc_info = tstate->exc_info;
-                /* Beware, this invalidates all b->b_* fields */
-                PyFrame_BlockSetup(f, EXCEPT_HANDLER, -1, STACK_LEVEL());
-                PUSH(exc_info->exc_traceback);
-                PUSH(exc_info->exc_value);
-                if (exc_info->exc_type != NULL) {
-                    PUSH(exc_info->exc_type);
-                }
-                else {
-                    Py_INCREF(Py_None);
-                    PUSH(Py_None);
-                }
+                PyObject *exc, *val, *tb; 
+                int handler = b->b_handler; 
+                _PyErr_StackItem *exc_info = tstate->exc_info; 
+                /* Beware, this invalidates all b->b_* fields */ 
+                PyFrame_BlockSetup(f, EXCEPT_HANDLER, -1, STACK_LEVEL()); 
+                PUSH(exc_info->exc_traceback); 
+                PUSH(exc_info->exc_value); 
+                if (exc_info->exc_type != NULL) { 
+                    PUSH(exc_info->exc_type); 
+                } 
+                else { 
+                    Py_INCREF(Py_None); 
+                    PUSH(Py_None); 
+                } 
                 _PyErr_Fetch(tstate, &exc, &val, &tb);
-                /* Make the raw exception data
-                   available to the handler,
-                   so a program can emulate the
-                   Python main loop. */
+                /* Make the raw exception data 
+                   available to the handler, 
+                   so a program can emulate the 
+                   Python main loop. */ 
                 _PyErr_NormalizeException(tstate, &exc, &val, &tb);
-                if (tb != NULL)
-                    PyException_SetTraceback(val, tb);
-                else
-                    PyException_SetTraceback(val, Py_None);
-                Py_INCREF(exc);
-                exc_info->exc_type = exc;
-                Py_INCREF(val);
-                exc_info->exc_value = val;
-                exc_info->exc_traceback = tb;
-                if (tb == NULL)
-                    tb = Py_None;
-                Py_INCREF(tb);
-                PUSH(tb);
-                PUSH(val);
-                PUSH(exc);
-                JUMPTO(handler);
+                if (tb != NULL) 
+                    PyException_SetTraceback(val, tb); 
+                else 
+                    PyException_SetTraceback(val, Py_None); 
+                Py_INCREF(exc); 
+                exc_info->exc_type = exc; 
+                Py_INCREF(val); 
+                exc_info->exc_value = val; 
+                exc_info->exc_traceback = tb; 
+                if (tb == NULL) 
+                    tb = Py_None; 
+                Py_INCREF(tb); 
+                PUSH(tb); 
+                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);
@@ -3805,102 +3805,102 @@ exception_unwind:
                 }
                 /* Resume normal execution */
                 goto main_loop;
-            }
-        } /* unwind stack */
-
+            } 
+        } /* unwind stack */ 
+ 
         /* End the loop as we still have an error */
         break;
     } /* main loop */
-
+ 
     assert(retval == NULL);
     assert(_PyErr_Occurred(tstate));
-
-    /* Pop remaining stack entries. */
-    while (!EMPTY()) {
-        PyObject *o = POP();
-        Py_XDECREF(o);
-    }
-
+ 
+    /* Pop remaining stack entries. */ 
+    while (!EMPTY()) { 
+        PyObject *o = POP(); 
+        Py_XDECREF(o); 
+    } 
+ 
 exiting:
-    if (tstate->use_tracing) {
-        if (tstate->c_tracefunc) {
+    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 (tstate->c_profilefunc) {
+            } 
+        } 
+        if (tstate->c_profilefunc) { 
             if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj,
                                      tstate, f, PyTrace_RETURN, retval)) {
-                Py_CLEAR(retval);
-            }
-        }
-    }
-
-    /* pop frame */
-exit_eval_frame:
-    if (PyDTrace_FUNCTION_RETURN_ENABLED())
-        dtrace_function_return(f);
+                Py_CLEAR(retval); 
+            } 
+        } 
+    } 
+ 
+    /* pop frame */ 
+exit_eval_frame: 
+    if (PyDTrace_FUNCTION_RETURN_ENABLED()) 
+        dtrace_function_return(f); 
     _Py_LeaveRecursiveCall(tstate);
-    f->f_executing = 0;
-    tstate->frame = f->f_back;
-
+    f->f_executing = 0; 
+    tstate->frame = f->f_back; 
+ 
     return _Py_CheckFunctionResult(tstate, NULL, retval, __func__);
-}
-
-static void
+} 
+ 
+static void 
 format_missing(PyThreadState *tstate, const char *kind,
                PyCodeObject *co, PyObject *names)
-{
-    int err;
-    Py_ssize_t len = PyList_GET_SIZE(names);
-    PyObject *name_str, *comma, *tail, *tmp;
-
-    assert(PyList_CheckExact(names));
-    assert(len >= 1);
-    /* Deal with the joys of natural language. */
-    switch (len) {
-    case 1:
-        name_str = PyList_GET_ITEM(names, 0);
-        Py_INCREF(name_str);
-        break;
-    case 2:
-        name_str = PyUnicode_FromFormat("%U and %U",
-                                        PyList_GET_ITEM(names, len - 2),
-                                        PyList_GET_ITEM(names, len - 1));
-        break;
-    default:
-        tail = PyUnicode_FromFormat(", %U, and %U",
-                                    PyList_GET_ITEM(names, len - 2),
-                                    PyList_GET_ITEM(names, len - 1));
-        if (tail == NULL)
-            return;
-        /* Chop off the last two objects in the list. This shouldn't actually
-           fail, but we can't be too careful. */
-        err = PyList_SetSlice(names, len - 2, len, NULL);
-        if (err == -1) {
-            Py_DECREF(tail);
-            return;
-        }
-        /* Stitch everything up into a nice comma-separated list. */
-        comma = PyUnicode_FromString(", ");
-        if (comma == NULL) {
-            Py_DECREF(tail);
-            return;
-        }
-        tmp = PyUnicode_Join(comma, names);
-        Py_DECREF(comma);
-        if (tmp == NULL) {
-            Py_DECREF(tail);
-            return;
-        }
-        name_str = PyUnicode_Concat(tmp, tail);
-        Py_DECREF(tmp);
-        Py_DECREF(tail);
-        break;
-    }
-    if (name_str == NULL)
-        return;
+{ 
+    int err; 
+    Py_ssize_t len = PyList_GET_SIZE(names); 
+    PyObject *name_str, *comma, *tail, *tmp; 
+ 
+    assert(PyList_CheckExact(names)); 
+    assert(len >= 1); 
+    /* Deal with the joys of natural language. */ 
+    switch (len) { 
+    case 1: 
+        name_str = PyList_GET_ITEM(names, 0); 
+        Py_INCREF(name_str); 
+        break; 
+    case 2: 
+        name_str = PyUnicode_FromFormat("%U and %U", 
+                                        PyList_GET_ITEM(names, len - 2), 
+                                        PyList_GET_ITEM(names, len - 1)); 
+        break; 
+    default: 
+        tail = PyUnicode_FromFormat(", %U, and %U", 
+                                    PyList_GET_ITEM(names, len - 2), 
+                                    PyList_GET_ITEM(names, len - 1)); 
+        if (tail == NULL) 
+            return; 
+        /* Chop off the last two objects in the list. This shouldn't actually 
+           fail, but we can't be too careful. */ 
+        err = PyList_SetSlice(names, len - 2, len, NULL); 
+        if (err == -1) { 
+            Py_DECREF(tail); 
+            return; 
+        } 
+        /* Stitch everything up into a nice comma-separated list. */ 
+        comma = PyUnicode_FromString(", "); 
+        if (comma == NULL) { 
+            Py_DECREF(tail); 
+            return; 
+        } 
+        tmp = PyUnicode_Join(comma, names); 
+        Py_DECREF(comma); 
+        if (tmp == NULL) { 
+            Py_DECREF(tail); 
+            return; 
+        } 
+        name_str = PyUnicode_Concat(tmp, tail); 
+        Py_DECREF(tmp); 
+        Py_DECREF(tail); 
+        break; 
+    } 
+    if (name_str == NULL) 
+        return; 
     _PyErr_Format(tstate, PyExc_TypeError,
                   "%U() missing %i required %s argument%s: %U",
                   co->co_name,
@@ -3908,93 +3908,93 @@ format_missing(PyThreadState *tstate, const char *kind,
                   kind,
                   len == 1 ? "" : "s",
                   name_str);
-    Py_DECREF(name_str);
-}
-
-static void
+    Py_DECREF(name_str); 
+} 
+ 
+static void 
 missing_arguments(PyThreadState *tstate, PyCodeObject *co,
                   Py_ssize_t missing, Py_ssize_t defcount,
-                  PyObject **fastlocals)
-{
-    Py_ssize_t i, j = 0;
-    Py_ssize_t start, end;
-    int positional = (defcount != -1);
-    const char *kind = positional ? "positional" : "keyword-only";
-    PyObject *missing_names;
-
-    /* Compute the names of the arguments that are missing. */
-    missing_names = PyList_New(missing);
-    if (missing_names == NULL)
-        return;
-    if (positional) {
-        start = 0;
-        end = co->co_argcount - defcount;
-    }
-    else {
-        start = co->co_argcount;
-        end = start + co->co_kwonlyargcount;
-    }
-    for (i = start; i < end; i++) {
-        if (GETLOCAL(i) == NULL) {
-            PyObject *raw = PyTuple_GET_ITEM(co->co_varnames, i);
-            PyObject *name = PyObject_Repr(raw);
-            if (name == NULL) {
-                Py_DECREF(missing_names);
-                return;
-            }
-            PyList_SET_ITEM(missing_names, j++, name);
-        }
-    }
-    assert(j == missing);
+                  PyObject **fastlocals) 
+{ 
+    Py_ssize_t i, j = 0; 
+    Py_ssize_t start, end; 
+    int positional = (defcount != -1); 
+    const char *kind = positional ? "positional" : "keyword-only"; 
+    PyObject *missing_names; 
+ 
+    /* Compute the names of the arguments that are missing. */ 
+    missing_names = PyList_New(missing); 
+    if (missing_names == NULL) 
+        return; 
+    if (positional) { 
+        start = 0; 
+        end = co->co_argcount - defcount; 
+    } 
+    else { 
+        start = co->co_argcount; 
+        end = start + co->co_kwonlyargcount; 
+    } 
+    for (i = start; i < end; i++) { 
+        if (GETLOCAL(i) == NULL) { 
+            PyObject *raw = PyTuple_GET_ITEM(co->co_varnames, i); 
+            PyObject *name = PyObject_Repr(raw); 
+            if (name == NULL) { 
+                Py_DECREF(missing_names); 
+                return; 
+            } 
+            PyList_SET_ITEM(missing_names, j++, name); 
+        } 
+    } 
+    assert(j == missing); 
     format_missing(tstate, kind, co, missing_names);
-    Py_DECREF(missing_names);
-}
-
-static void
+    Py_DECREF(missing_names); 
+} 
+ 
+static void 
 too_many_positional(PyThreadState *tstate, PyCodeObject *co,
                     Py_ssize_t given, Py_ssize_t defcount,
-                    PyObject **fastlocals)
-{
-    int plural;
-    Py_ssize_t kwonly_given = 0;
-    Py_ssize_t i;
-    PyObject *sig, *kwonly_sig;
-    Py_ssize_t co_argcount = co->co_argcount;
-
-    assert((co->co_flags & CO_VARARGS) == 0);
-    /* Count missing keyword-only args. */
-    for (i = co_argcount; i < co_argcount + co->co_kwonlyargcount; i++) {
-        if (GETLOCAL(i) != NULL) {
-            kwonly_given++;
-        }
-    }
-    if (defcount) {
-        Py_ssize_t atleast = co_argcount - defcount;
-        plural = 1;
-        sig = PyUnicode_FromFormat("from %zd to %zd", atleast, co_argcount);
-    }
-    else {
-        plural = (co_argcount != 1);
-        sig = PyUnicode_FromFormat("%zd", co_argcount);
-    }
-    if (sig == NULL)
-        return;
-    if (kwonly_given) {
-        const char *format = " positional argument%s (and %zd keyword-only argument%s)";
-        kwonly_sig = PyUnicode_FromFormat(format,
-                                          given != 1 ? "s" : "",
-                                          kwonly_given,
-                                          kwonly_given != 1 ? "s" : "");
-        if (kwonly_sig == NULL) {
-            Py_DECREF(sig);
-            return;
-        }
-    }
-    else {
-        /* This will not fail. */
-        kwonly_sig = PyUnicode_FromString("");
-        assert(kwonly_sig != NULL);
-    }
+                    PyObject **fastlocals) 
+{ 
+    int plural; 
+    Py_ssize_t kwonly_given = 0; 
+    Py_ssize_t i; 
+    PyObject *sig, *kwonly_sig; 
+    Py_ssize_t co_argcount = co->co_argcount; 
+ 
+    assert((co->co_flags & CO_VARARGS) == 0); 
+    /* Count missing keyword-only args. */ 
+    for (i = co_argcount; i < co_argcount + co->co_kwonlyargcount; i++) { 
+        if (GETLOCAL(i) != NULL) { 
+            kwonly_given++; 
+        } 
+    } 
+    if (defcount) { 
+        Py_ssize_t atleast = co_argcount - defcount; 
+        plural = 1; 
+        sig = PyUnicode_FromFormat("from %zd to %zd", atleast, co_argcount); 
+    } 
+    else { 
+        plural = (co_argcount != 1); 
+        sig = PyUnicode_FromFormat("%zd", co_argcount); 
+    } 
+    if (sig == NULL) 
+        return; 
+    if (kwonly_given) { 
+        const char *format = " positional argument%s (and %zd keyword-only argument%s)"; 
+        kwonly_sig = PyUnicode_FromFormat(format, 
+                                          given != 1 ? "s" : "", 
+                                          kwonly_given, 
+                                          kwonly_given != 1 ? "s" : ""); 
+        if (kwonly_sig == NULL) { 
+            Py_DECREF(sig); 
+            return; 
+        } 
+    } 
+    else { 
+        /* This will not fail. */ 
+        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,
@@ -4003,10 +4003,10 @@ too_many_positional(PyThreadState *tstate, PyCodeObject *co,
                   given,
                   kwonly_sig,
                   given == 1 && !kwonly_given ? "was" : "were");
-    Py_DECREF(sig);
-    Py_DECREF(kwonly_sig);
-}
-
+    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)
@@ -4068,121 +4068,121 @@ fail:
 
 }
 
-/* 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 *
+/* 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,
-           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)
-{
+           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) 
+{ 
     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;
+    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;
-    PyObject *kwdict;
-
-    if (globals == NULL) {
+    PyObject *kwdict; 
+ 
+    if (globals == NULL) { 
         _PyErr_SetString(tstate, PyExc_SystemError,
                          "PyEval_EvalCodeEx: NULL globals");
-        return NULL;
-    }
-
-    /* Create the frame */
-    f = _PyFrame_New_NoTrack(tstate, co, globals, locals);
-    if (f == NULL) {
-        return NULL;
-    }
-    fastlocals = f->f_localsplus;
-    freevars = f->f_localsplus + co->co_nlocals;
-
-    /* Create a dictionary for keyword parameters (**kwags) */
-    if (co->co_flags & CO_VARKEYWORDS) {
-        kwdict = PyDict_New();
-        if (kwdict == NULL)
-            goto fail;
-        i = total_args;
-        if (co->co_flags & CO_VARARGS) {
-            i++;
-        }
-        SETLOCAL(i, kwdict);
-    }
-    else {
-        kwdict = NULL;
-    }
-
+        return NULL; 
+    } 
+ 
+    /* Create the frame */ 
+    f = _PyFrame_New_NoTrack(tstate, co, globals, locals); 
+    if (f == NULL) { 
+        return NULL; 
+    } 
+    fastlocals = f->f_localsplus; 
+    freevars = f->f_localsplus + co->co_nlocals; 
+ 
+    /* Create a dictionary for keyword parameters (**kwags) */ 
+    if (co->co_flags & CO_VARKEYWORDS) { 
+        kwdict = PyDict_New(); 
+        if (kwdict == NULL) 
+            goto fail; 
+        i = total_args; 
+        if (co->co_flags & CO_VARARGS) { 
+            i++; 
+        } 
+        SETLOCAL(i, kwdict); 
+    } 
+    else { 
+        kwdict = NULL; 
+    } 
+ 
     /* Copy all positional arguments into local variables */
-    if (argcount > co->co_argcount) {
-        n = co->co_argcount;
-    }
-    else {
-        n = argcount;
-    }
+    if (argcount > co->co_argcount) { 
+        n = co->co_argcount; 
+    } 
+    else { 
+        n = argcount; 
+    } 
     for (j = 0; j < n; j++) {
         x = args[j];
-        Py_INCREF(x);
+        Py_INCREF(x); 
         SETLOCAL(j, x);
-    }
-
-    /* Pack other positional arguments into the *args argument */
-    if (co->co_flags & CO_VARARGS) {
+    } 
+ 
+    /* Pack other positional arguments into the *args argument */ 
+    if (co->co_flags & CO_VARARGS) { 
         u = _PyTuple_FromArray(args + n, argcount - n);
-        if (u == NULL) {
-            goto fail;
-        }
-        SETLOCAL(total_args, u);
-    }
-
-    /* Handle keyword arguments passed as two strided arrays */
-    kwcount *= kwstep;
-    for (i = 0; i < kwcount; i += kwstep) {
-        PyObject **co_varnames;
-        PyObject *keyword = kwnames[i];
-        PyObject *value = kwargs[i];
-        Py_ssize_t j;
-
-        if (keyword == NULL || !PyUnicode_Check(keyword)) {
+        if (u == NULL) { 
+            goto fail; 
+        } 
+        SETLOCAL(total_args, u); 
+    } 
+ 
+    /* Handle keyword arguments passed as two strided arrays */ 
+    kwcount *= kwstep; 
+    for (i = 0; i < kwcount; i += kwstep) { 
+        PyObject **co_varnames; 
+        PyObject *keyword = kwnames[i]; 
+        PyObject *value = kwargs[i]; 
+        Py_ssize_t j; 
+ 
+        if (keyword == NULL || !PyUnicode_Check(keyword)) { 
             _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;
+            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++) {
-            PyObject *name = co_varnames[j];
-            if (name == keyword) {
-                goto kw_found;
-            }
-        }
-
-        /* Slow fallback, just in case */
+            PyObject *name = co_varnames[j]; 
+            if (name == keyword) { 
+                goto kw_found; 
+            } 
+        } 
+ 
+        /* Slow fallback, just in case */ 
         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) {
-                goto kw_found;
-            }
-            else if (cmp < 0) {
-                goto fail;
-            }
-        }
-
-        assert(j >= total_args);
-        if (kwdict == NULL) {
+            PyObject *name = co_varnames[j]; 
+            int cmp = PyObject_RichCompareBool( keyword, name, Py_EQ); 
+            if (cmp > 0) { 
+                goto kw_found; 
+            } 
+            else if (cmp < 0) { 
+                goto fail; 
+            } 
+        } 
+ 
+        assert(j >= total_args); 
+        if (kwdict == NULL) { 
 
             if (co->co_posonlyargcount
                 && positional_only_passed_as_keyword(tstate, co,
@@ -4194,161 +4194,161 @@ _PyEval_EvalCode(PyThreadState *tstate,
             _PyErr_Format(tstate, PyExc_TypeError,
                           "%U() got an unexpected keyword argument '%S'",
                           co->co_name, keyword);
-            goto fail;
-        }
-
-        if (PyDict_SetItem(kwdict, keyword, value) == -1) {
-            goto fail;
-        }
-        continue;
-
-      kw_found:
-        if (GETLOCAL(j) != NULL) {
+            goto fail; 
+        } 
+ 
+        if (PyDict_SetItem(kwdict, keyword, value) == -1) { 
+            goto fail; 
+        } 
+        continue; 
+ 
+      kw_found: 
+        if (GETLOCAL(j) != NULL) { 
             _PyErr_Format(tstate, PyExc_TypeError,
                           "%U() got multiple values for argument '%S'",
                           co->co_name, keyword);
-            goto fail;
-        }
-        Py_INCREF(value);
-        SETLOCAL(j, value);
-    }
-
-    /* Check the number of positional arguments */
+            goto fail; 
+        } 
+        Py_INCREF(value); 
+        SETLOCAL(j, value); 
+    } 
+ 
+    /* Check the number of positional arguments */ 
     if ((argcount > co->co_argcount) && !(co->co_flags & CO_VARARGS)) {
         too_many_positional(tstate, co, argcount, defcount, fastlocals);
-        goto fail;
-    }
-
-    /* Add missing positional arguments (copy default values from defs) */
-    if (argcount < co->co_argcount) {
-        Py_ssize_t m = co->co_argcount - defcount;
-        Py_ssize_t missing = 0;
-        for (i = argcount; i < m; i++) {
-            if (GETLOCAL(i) == NULL) {
-                missing++;
-            }
-        }
-        if (missing) {
+        goto fail; 
+    } 
+ 
+    /* Add missing positional arguments (copy default values from defs) */ 
+    if (argcount < co->co_argcount) { 
+        Py_ssize_t m = co->co_argcount - defcount; 
+        Py_ssize_t missing = 0; 
+        for (i = argcount; i < m; i++) { 
+            if (GETLOCAL(i) == NULL) { 
+                missing++; 
+            } 
+        } 
+        if (missing) { 
             missing_arguments(tstate, co, missing, defcount, fastlocals);
-            goto fail;
-        }
-        if (n > m)
-            i = n - m;
-        else
-            i = 0;
-        for (; i < defcount; i++) {
-            if (GETLOCAL(m+i) == NULL) {
-                PyObject *def = defs[i];
-                Py_INCREF(def);
-                SETLOCAL(m+i, def);
-            }
-        }
-    }
-
-    /* Add missing keyword arguments (copy default values from kwdefs) */
-    if (co->co_kwonlyargcount > 0) {
-        Py_ssize_t missing = 0;
-        for (i = co->co_argcount; i < total_args; i++) {
-            PyObject *name;
-            if (GETLOCAL(i) != NULL)
-                continue;
-            name = PyTuple_GET_ITEM(co->co_varnames, i);
-            if (kwdefs != NULL) {
+            goto fail; 
+        } 
+        if (n > m) 
+            i = n - m; 
+        else 
+            i = 0; 
+        for (; i < defcount; i++) { 
+            if (GETLOCAL(m+i) == NULL) { 
+                PyObject *def = defs[i]; 
+                Py_INCREF(def); 
+                SETLOCAL(m+i, def); 
+            } 
+        } 
+    } 
+ 
+    /* Add missing keyword arguments (copy default values from kwdefs) */ 
+    if (co->co_kwonlyargcount > 0) { 
+        Py_ssize_t missing = 0; 
+        for (i = co->co_argcount; i < total_args; i++) { 
+            PyObject *name; 
+            if (GETLOCAL(i) != NULL) 
+                continue; 
+            name = PyTuple_GET_ITEM(co->co_varnames, i); 
+            if (kwdefs != NULL) { 
                 PyObject *def = PyDict_GetItemWithError(kwdefs, name);
-                if (def) {
-                    Py_INCREF(def);
-                    SETLOCAL(i, def);
-                    continue;
-                }
+                if (def) { 
+                    Py_INCREF(def); 
+                    SETLOCAL(i, def); 
+                    continue; 
+                } 
                 else if (_PyErr_Occurred(tstate)) {
                     goto fail;
                 }
-            }
-            missing++;
-        }
-        if (missing) {
+            } 
+            missing++; 
+        } 
+        if (missing) { 
             missing_arguments(tstate, co, missing, -1, fastlocals);
-            goto fail;
-        }
-    }
-
-    /* Allocate and initialize storage for cell vars, and copy free
-       vars into frame. */
-    for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
-        PyObject *c;
-        Py_ssize_t arg;
-        /* Possibly account for the cell variable being an argument. */
-        if (co->co_cell2arg != NULL &&
-            (arg = co->co_cell2arg[i]) != CO_CELL_NOT_AN_ARG) {
-            c = PyCell_New(GETLOCAL(arg));
-            /* Clear the local copy. */
-            SETLOCAL(arg, NULL);
-        }
-        else {
-            c = PyCell_New(NULL);
-        }
-        if (c == NULL)
-            goto fail;
-        SETLOCAL(co->co_nlocals + i, c);
-    }
-
-    /* Copy closure variables to free variables */
-    for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
-        PyObject *o = PyTuple_GET_ITEM(closure, i);
-        Py_INCREF(o);
-        freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
-    }
-
-    /* Handle generator/coroutine/asynchronous generator */
-    if (co->co_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {
-        PyObject *gen;
-        int is_coro = co->co_flags & CO_COROUTINE;
-
-        /* Don't need to keep the reference to f_back, it will be set
-         * when the generator is resumed. */
-        Py_CLEAR(f->f_back);
-
-        /* Create a new generator that owns the ready to run frame
-         * and return that as the value. */
-        if (is_coro) {
-            gen = PyCoro_New(f, name, qualname);
-        } else if (co->co_flags & CO_ASYNC_GENERATOR) {
-            gen = PyAsyncGen_New(f, name, qualname);
-        } else {
-            gen = PyGen_NewWithQualName(f, name, qualname);
-        }
-        if (gen == NULL) {
-            return NULL;
-        }
-
-        _PyObject_GC_TRACK(f);
-
-        return gen;
-    }
-
+            goto fail; 
+        } 
+    } 
+ 
+    /* Allocate and initialize storage for cell vars, and copy free 
+       vars into frame. */ 
+    for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) { 
+        PyObject *c; 
+        Py_ssize_t arg; 
+        /* Possibly account for the cell variable being an argument. */ 
+        if (co->co_cell2arg != NULL && 
+            (arg = co->co_cell2arg[i]) != CO_CELL_NOT_AN_ARG) { 
+            c = PyCell_New(GETLOCAL(arg)); 
+            /* Clear the local copy. */ 
+            SETLOCAL(arg, NULL); 
+        } 
+        else { 
+            c = PyCell_New(NULL); 
+        } 
+        if (c == NULL) 
+            goto fail; 
+        SETLOCAL(co->co_nlocals + i, c); 
+    } 
+ 
+    /* Copy closure variables to free variables */ 
+    for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) { 
+        PyObject *o = PyTuple_GET_ITEM(closure, i); 
+        Py_INCREF(o); 
+        freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o; 
+    } 
+ 
+    /* Handle generator/coroutine/asynchronous generator */ 
+    if (co->co_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) { 
+        PyObject *gen; 
+        int is_coro = co->co_flags & CO_COROUTINE; 
+ 
+        /* Don't need to keep the reference to f_back, it will be set 
+         * when the generator is resumed. */ 
+        Py_CLEAR(f->f_back); 
+ 
+        /* Create a new generator that owns the ready to run frame 
+         * and return that as the value. */ 
+        if (is_coro) { 
+            gen = PyCoro_New(f, name, qualname); 
+        } else if (co->co_flags & CO_ASYNC_GENERATOR) { 
+            gen = PyAsyncGen_New(f, name, qualname); 
+        } else { 
+            gen = PyGen_NewWithQualName(f, name, qualname); 
+        } 
+        if (gen == NULL) { 
+            return NULL; 
+        } 
+ 
+        _PyObject_GC_TRACK(f); 
+ 
+        return gen; 
+    } 
+ 
     retval = _PyEval_EvalFrame(tstate, f, 0);
-
-fail: /* Jump here from prelude on failure */
-
-    /* decref'ing the frame can cause __del__ methods to get invoked,
-       which can call back into Python.  While we're done with the
-       current Python frame (f), the associated C stack is still in use,
-       so recursion_depth must be boosted for the duration.
-    */
-    if (Py_REFCNT(f) > 1) {
-        Py_DECREF(f);
-        _PyObject_GC_TRACK(f);
-    }
-    else {
-        ++tstate->recursion_depth;
-        Py_DECREF(f);
-        --tstate->recursion_depth;
-    }
-    return retval;
-}
-
-
-PyObject *
+ 
+fail: /* Jump here from prelude on failure */ 
+ 
+    /* decref'ing the frame can cause __del__ methods to get invoked, 
+       which can call back into Python.  While we're done with the 
+       current Python frame (f), the associated C stack is still in use, 
+       so recursion_depth must be boosted for the duration. 
+    */ 
+    if (Py_REFCNT(f) > 1) { 
+        Py_DECREF(f); 
+        _PyObject_GC_TRACK(f); 
+    } 
+    else { 
+        ++tstate->recursion_depth; 
+        Py_DECREF(f); 
+        --tstate->recursion_depth; 
+    } 
+    return retval; 
+} 
+ 
+
+PyObject * 
 _PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals,
            PyObject *const *args, Py_ssize_t argcount,
            PyObject *const *kwnames, PyObject *const *kwargs,
@@ -4368,376 +4368,376 @@ _PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals,
 }
 
 PyObject *
-PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
-                  PyObject *const *args, int argcount,
-                  PyObject *const *kws, int kwcount,
-                  PyObject *const *defs, int defcount,
-                  PyObject *kwdefs, PyObject *closure)
-{
-    return _PyEval_EvalCodeWithName(_co, globals, locals,
-                                    args, argcount,
-                                    kws, kws != NULL ? kws + 1 : NULL,
-                                    kwcount, 2,
-                                    defs, defcount,
-                                    kwdefs, closure,
-                                    NULL, NULL);
-}
-
-static PyObject *
+PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals, 
+                  PyObject *const *args, int argcount, 
+                  PyObject *const *kws, int kwcount, 
+                  PyObject *const *defs, int defcount, 
+                  PyObject *kwdefs, PyObject *closure) 
+{ 
+    return _PyEval_EvalCodeWithName(_co, globals, locals, 
+                                    args, argcount, 
+                                    kws, kws != NULL ? kws + 1 : NULL, 
+                                    kwcount, 2, 
+                                    defs, defcount, 
+                                    kwdefs, closure, 
+                                    NULL, NULL); 
+} 
+ 
+static PyObject * 
 special_lookup(PyThreadState *tstate, PyObject *o, _Py_Identifier *id)
-{
-    PyObject *res;
-    res = _PyObject_LookupSpecial(o, id);
+{ 
+    PyObject *res; 
+    res = _PyObject_LookupSpecial(o, id); 
     if (res == NULL && !_PyErr_Occurred(tstate)) {
         _PyErr_SetObject(tstate, PyExc_AttributeError, _PyUnicode_FromId(id));
-        return NULL;
-    }
-    return res;
-}
-
-
-/* Logic for the raise statement (too complicated for inlining).
-   This *consumes* a reference count to each of its arguments. */
-static int
+        return NULL; 
+    } 
+    return res; 
+} 
+ 
+ 
+/* 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)
-{
-    PyObject *type = NULL, *value = NULL;
-
-    if (exc == NULL) {
-        /* Reraise */
-        _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate);
-        PyObject *tb;
-        type = exc_info->exc_type;
-        value = exc_info->exc_value;
-        tb = exc_info->exc_traceback;
-        if (type == Py_None || type == NULL) {
+{ 
+    PyObject *type = NULL, *value = NULL; 
+ 
+    if (exc == NULL) { 
+        /* Reraise */ 
+        _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate); 
+        PyObject *tb; 
+        type = exc_info->exc_type; 
+        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");
-            return 0;
-        }
-        Py_XINCREF(type);
-        Py_XINCREF(value);
-        Py_XINCREF(tb);
+            return 0; 
+        } 
+        Py_XINCREF(type); 
+        Py_XINCREF(value); 
+        Py_XINCREF(tb); 
         _PyErr_Restore(tstate, type, value, tb);
-        return 1;
-    }
-
-    /* We support the following forms of raise:
-       raise
-       raise <instance>
-       raise <type> */
-
-    if (PyExceptionClass_Check(exc)) {
-        type = exc;
-        value = _PyObject_CallNoArg(exc);
-        if (value == NULL)
-            goto raise_error;
-        if (!PyExceptionInstance_Check(value)) {
+        return 1; 
+    } 
+ 
+    /* We support the following forms of raise: 
+       raise 
+       raise <instance> 
+       raise <type> */ 
+ 
+    if (PyExceptionClass_Check(exc)) { 
+        type = exc; 
+        value = _PyObject_CallNoArg(exc); 
+        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;
-        }
-    }
-    else if (PyExceptionInstance_Check(exc)) {
-        value = exc;
-        type = PyExceptionInstance_Class(exc);
-        Py_INCREF(type);
-    }
-    else {
-        /* Not something you can raise.  You get an exception
-           anyway, just not what you specified :-) */
-        Py_DECREF(exc);
+        } 
+    } 
+    else if (PyExceptionInstance_Check(exc)) { 
+        value = exc; 
+        type = PyExceptionInstance_Class(exc); 
+        Py_INCREF(type); 
+    } 
+    else { 
+        /* 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");
-        goto raise_error;
-    }
-
-    assert(type != NULL);
-    assert(value != NULL);
-
-    if (cause) {
-        PyObject *fixed_cause;
-        if (PyExceptionClass_Check(cause)) {
-            fixed_cause = _PyObject_CallNoArg(cause);
-            if (fixed_cause == NULL)
-                goto raise_error;
-            Py_DECREF(cause);
-        }
-        else if (PyExceptionInstance_Check(cause)) {
-            fixed_cause = cause;
-        }
-        else if (cause == Py_None) {
-            Py_DECREF(cause);
-            fixed_cause = NULL;
-        }
-        else {
+        goto raise_error; 
+    } 
+ 
+    assert(type != NULL); 
+    assert(value != NULL); 
+ 
+    if (cause) { 
+        PyObject *fixed_cause; 
+        if (PyExceptionClass_Check(cause)) { 
+            fixed_cause = _PyObject_CallNoArg(cause); 
+            if (fixed_cause == NULL) 
+                goto raise_error; 
+            Py_DECREF(cause); 
+        } 
+        else if (PyExceptionInstance_Check(cause)) { 
+            fixed_cause = cause; 
+        } 
+        else if (cause == Py_None) { 
+            Py_DECREF(cause); 
+            fixed_cause = NULL; 
+        } 
+        else { 
             _PyErr_SetString(tstate, PyExc_TypeError,
                              "exception causes must derive from "
                              "BaseException");
-            goto raise_error;
-        }
-        PyException_SetCause(value, fixed_cause);
-    }
-
+            goto raise_error; 
+        } 
+        PyException_SetCause(value, fixed_cause); 
+    } 
+ 
     _PyErr_SetObject(tstate, type, value);
     /* _PyErr_SetObject incref's its arguments */
-    Py_DECREF(value);
-    Py_DECREF(type);
-    return 0;
-
-raise_error:
-    Py_XDECREF(value);
-    Py_XDECREF(type);
-    Py_XDECREF(cause);
-    return 0;
-}
-
-/* Iterate v argcnt times and store the results on the stack (via decreasing
-   sp).  Return 1 for success, 0 if error.
-
-   If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack
-   with a variable target.
-*/
-
-static int
+    Py_DECREF(value); 
+    Py_DECREF(type); 
+    return 0; 
+ 
+raise_error: 
+    Py_XDECREF(value); 
+    Py_XDECREF(type); 
+    Py_XDECREF(cause); 
+    return 0; 
+} 
+ 
+/* Iterate v argcnt times and store the results on the stack (via decreasing 
+   sp).  Return 1 for success, 0 if error. 
+ 
+   If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack 
+   with a variable target. 
+*/ 
+ 
+static int 
 unpack_iterable(PyThreadState *tstate, PyObject *v,
                 int argcnt, int argcntafter, PyObject **sp)
-{
-    int i = 0, j = 0;
-    Py_ssize_t ll = 0;
-    PyObject *it;  /* iter(v) */
-    PyObject *w;
-    PyObject *l = NULL; /* variable list */
-
-    assert(v != NULL);
-
-    it = PyObject_GetIter(v);
-    if (it == NULL) {
+{ 
+    int i = 0, j = 0; 
+    Py_ssize_t ll = 0; 
+    PyObject *it;  /* iter(v) */ 
+    PyObject *w; 
+    PyObject *l = NULL; /* variable list */ 
+ 
+    assert(v != NULL); 
+ 
+    it = PyObject_GetIter(v); 
+    if (it == NULL) { 
         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);
-        }
-        return 0;
-    }
-
-    for (; i < argcnt; i++) {
-        w = PyIter_Next(it);
-        if (w == NULL) {
-            /* Iterator done, via error or exhaustion. */
+        } 
+        return 0; 
+    } 
+ 
+    for (; i < argcnt; i++) { 
+        w = PyIter_Next(it); 
+        if (w == NULL) { 
+            /* Iterator done, via error or exhaustion. */ 
             if (!_PyErr_Occurred(tstate)) {
-                if (argcntafter == -1) {
+                if (argcntafter == -1) { 
                     _PyErr_Format(tstate, PyExc_ValueError,
                                   "not enough values to unpack "
                                   "(expected %d, got %d)",
                                   argcnt, i);
-                }
-                else {
+                } 
+                else { 
                     _PyErr_Format(tstate, PyExc_ValueError,
                                   "not enough values to unpack "
                                   "(expected at least %d, got %d)",
                                   argcnt + argcntafter, i);
-                }
-            }
-            goto Error;
-        }
-        *--sp = w;
-    }
-
-    if (argcntafter == -1) {
-        /* We better have exhausted the iterator now. */
-        w = PyIter_Next(it);
-        if (w == NULL) {
+                } 
+            } 
+            goto Error; 
+        } 
+        *--sp = w; 
+    } 
+ 
+    if (argcntafter == -1) { 
+        /* We better have exhausted the iterator now. */ 
+        w = PyIter_Next(it); 
+        if (w == NULL) { 
             if (_PyErr_Occurred(tstate))
-                goto Error;
-            Py_DECREF(it);
-            return 1;
-        }
-        Py_DECREF(w);
+                goto Error; 
+            Py_DECREF(it); 
+            return 1; 
+        } 
+        Py_DECREF(w); 
         _PyErr_Format(tstate, PyExc_ValueError,
                       "too many values to unpack (expected %d)",
                       argcnt);
-        goto Error;
-    }
-
-    l = PySequence_List(it);
-    if (l == NULL)
-        goto Error;
-    *--sp = l;
-    i++;
-
-    ll = PyList_GET_SIZE(l);
-    if (ll < argcntafter) {
+        goto Error; 
+    } 
+ 
+    l = PySequence_List(it); 
+    if (l == NULL) 
+        goto Error; 
+    *--sp = l; 
+    i++; 
+ 
+    ll = PyList_GET_SIZE(l); 
+    if (ll < argcntafter) { 
         _PyErr_Format(tstate, PyExc_ValueError,
-            "not enough values to unpack (expected at least %d, got %zd)",
-            argcnt + argcntafter, argcnt + ll);
-        goto Error;
-    }
-
-    /* Pop the "after-variable" args off the list. */
-    for (j = argcntafter; j > 0; j--, i++) {
-        *--sp = PyList_GET_ITEM(l, ll - j);
-    }
-    /* Resize the list. */
+            "not enough values to unpack (expected at least %d, got %zd)", 
+            argcnt + argcntafter, argcnt + ll); 
+        goto Error; 
+    } 
+ 
+    /* Pop the "after-variable" args off the list. */ 
+    for (j = argcntafter; j > 0; j--, i++) { 
+        *--sp = PyList_GET_ITEM(l, ll - j); 
+    } 
+    /* Resize the list. */ 
     Py_SET_SIZE(l, ll - argcntafter);
-    Py_DECREF(it);
-    return 1;
-
-Error:
-    for (; i > 0; i--, sp++)
-        Py_DECREF(*sp);
-    Py_XDECREF(it);
-    return 0;
-}
-
-
-#ifdef LLTRACE
-static int
+    Py_DECREF(it); 
+    return 1; 
+ 
+Error: 
+    for (; i > 0; i--, sp++) 
+        Py_DECREF(*sp); 
+    Py_XDECREF(it); 
+    return 0; 
+} 
+ 
+ 
+#ifdef LLTRACE 
+static int 
 prtrace(PyThreadState *tstate, PyObject *v, const char *str)
-{
-    printf("%s ", 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);
     }
-    printf("\n");
+    printf("\n"); 
     PyErr_Restore(type, value, traceback);
-    return 1;
-}
-#endif
-
-static void
-call_exc_trace(Py_tracefunc func, PyObject *self,
-               PyThreadState *tstate, PyFrameObject *f)
-{
-    PyObject *type, *value, *traceback, *orig_traceback, *arg;
-    int err;
+    return 1; 
+} 
+#endif 
+ 
+static void 
+call_exc_trace(Py_tracefunc func, PyObject *self, 
+               PyThreadState *tstate, PyFrameObject *f) 
+{ 
+    PyObject *type, *value, *traceback, *orig_traceback, *arg; 
+    int err; 
     _PyErr_Fetch(tstate, &type, &value, &orig_traceback);
-    if (value == NULL) {
-        value = Py_None;
-        Py_INCREF(value);
-    }
+    if (value == NULL) { 
+        value = Py_None; 
+        Py_INCREF(value); 
+    } 
     _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) {
+    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);
-        return;
-    }
-    err = call_trace(func, self, tstate, f, PyTrace_EXCEPTION, arg);
-    Py_DECREF(arg);
+        return; 
+    } 
+    err = call_trace(func, self, tstate, f, PyTrace_EXCEPTION, arg); 
+    Py_DECREF(arg); 
     if (err == 0) {
         _PyErr_Restore(tstate, type, value, orig_traceback);
     }
-    else {
-        Py_XDECREF(type);
-        Py_XDECREF(value);
-        Py_XDECREF(orig_traceback);
-    }
-}
-
-static int
-call_trace_protected(Py_tracefunc func, PyObject *obj,
-                     PyThreadState *tstate, PyFrameObject *frame,
-                     int what, PyObject *arg)
-{
-    PyObject *type, *value, *traceback;
-    int err;
+    else { 
+        Py_XDECREF(type); 
+        Py_XDECREF(value); 
+        Py_XDECREF(orig_traceback); 
+    } 
+} 
+ 
+static int 
+call_trace_protected(Py_tracefunc func, PyObject *obj, 
+                     PyThreadState *tstate, PyFrameObject *frame, 
+                     int what, PyObject *arg) 
+{ 
+    PyObject *type, *value, *traceback; 
+    int err; 
     _PyErr_Fetch(tstate, &type, &value, &traceback);
-    err = call_trace(func, obj, tstate, frame, what, arg);
-    if (err == 0)
-    {
+    err = call_trace(func, obj, tstate, frame, what, arg); 
+    if (err == 0) 
+    { 
         _PyErr_Restore(tstate, type, value, traceback);
-        return 0;
-    }
-    else {
-        Py_XDECREF(type);
-        Py_XDECREF(value);
-        Py_XDECREF(traceback);
-        return -1;
-    }
-}
-
-static int
-call_trace(Py_tracefunc func, PyObject *obj,
-           PyThreadState *tstate, PyFrameObject *frame,
-           int what, PyObject *arg)
-{
-    int result;
-    if (tstate->tracing)
-        return 0;
-    tstate->tracing++;
-    tstate->use_tracing = 0;
-    result = func(obj, frame, what, arg);
-    tstate->use_tracing = ((tstate->c_tracefunc != NULL)
-                           || (tstate->c_profilefunc != NULL));
-    tstate->tracing--;
-    return result;
-}
-
-PyObject *
-_PyEval_CallTracing(PyObject *func, PyObject *args)
-{
+        return 0; 
+    } 
+    else { 
+        Py_XDECREF(type); 
+        Py_XDECREF(value); 
+        Py_XDECREF(traceback); 
+        return -1; 
+    } 
+} 
+ 
+static int 
+call_trace(Py_tracefunc func, PyObject *obj, 
+           PyThreadState *tstate, PyFrameObject *frame, 
+           int what, PyObject *arg) 
+{ 
+    int result; 
+    if (tstate->tracing) 
+        return 0; 
+    tstate->tracing++; 
+    tstate->use_tracing = 0; 
+    result = func(obj, frame, what, arg); 
+    tstate->use_tracing = ((tstate->c_tracefunc != NULL) 
+                           || (tstate->c_profilefunc != NULL)); 
+    tstate->tracing--; 
+    return result; 
+} 
+ 
+PyObject * 
+_PyEval_CallTracing(PyObject *func, PyObject *args) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
-    int save_tracing = tstate->tracing;
-    int save_use_tracing = tstate->use_tracing;
-    PyObject *result;
-
-    tstate->tracing = 0;
-    tstate->use_tracing = ((tstate->c_tracefunc != NULL)
-                           || (tstate->c_profilefunc != NULL));
-    result = PyObject_Call(func, args, NULL);
-    tstate->tracing = save_tracing;
-    tstate->use_tracing = save_use_tracing;
-    return result;
-}
-
-/* See Objects/lnotab_notes.txt for a description of how tracing works. */
-static int
-maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
-                      PyThreadState *tstate, PyFrameObject *frame,
-                      int *instr_lb, int *instr_ub, int *instr_prev)
-{
-    int result = 0;
-    int line = frame->f_lineno;
-
-    /* If the last instruction executed isn't in the current
-       instruction window, reset the window.
-    */
-    if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) {
-        PyAddrPair bounds;
-        line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
-                                       &bounds);
-        *instr_lb = bounds.ap_lower;
-        *instr_ub = bounds.ap_upper;
-    }
-    /* If the last instruction falls at the start of a line or if it
-       represents a jump backwards, update the frame's line number and
-       then call the trace function if we're tracing source lines.
-    */
-    if ((frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev)) {
-        frame->f_lineno = line;
-        if (frame->f_trace_lines) {
-            result = call_trace(func, obj, tstate, frame, PyTrace_LINE, Py_None);
-        }
-    }
-    /* Always emit an opcode event if we're tracing all opcodes. */
-    if (frame->f_trace_opcodes) {
-        result = call_trace(func, obj, tstate, frame, PyTrace_OPCODE, Py_None);
-    }
-    *instr_prev = frame->f_lasti;
-    return result;
-}
-
+    int save_tracing = tstate->tracing; 
+    int save_use_tracing = tstate->use_tracing; 
+    PyObject *result; 
+ 
+    tstate->tracing = 0; 
+    tstate->use_tracing = ((tstate->c_tracefunc != NULL) 
+                           || (tstate->c_profilefunc != NULL)); 
+    result = PyObject_Call(func, args, NULL); 
+    tstate->tracing = save_tracing; 
+    tstate->use_tracing = save_use_tracing; 
+    return result; 
+} 
+ 
+/* See Objects/lnotab_notes.txt for a description of how tracing works. */ 
+static int 
+maybe_call_line_trace(Py_tracefunc func, PyObject *obj, 
+                      PyThreadState *tstate, PyFrameObject *frame, 
+                      int *instr_lb, int *instr_ub, int *instr_prev) 
+{ 
+    int result = 0; 
+    int line = frame->f_lineno; 
+ 
+    /* If the last instruction executed isn't in the current 
+       instruction window, reset the window. 
+    */ 
+    if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) { 
+        PyAddrPair bounds; 
+        line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti, 
+                                       &bounds); 
+        *instr_lb = bounds.ap_lower; 
+        *instr_ub = bounds.ap_upper; 
+    } 
+    /* If the last instruction falls at the start of a line or if it 
+       represents a jump backwards, update the frame's line number and 
+       then call the trace function if we're tracing source lines. 
+    */ 
+    if ((frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev)) { 
+        frame->f_lineno = line; 
+        if (frame->f_trace_lines) { 
+            result = call_trace(func, obj, tstate, frame, PyTrace_LINE, Py_None); 
+        } 
+    } 
+    /* Always emit an opcode event if we're tracing all opcodes. */ 
+    if (frame->f_trace_opcodes) { 
+        result = call_trace(func, obj, tstate, frame, PyTrace_OPCODE, Py_None); 
+    } 
+    *instr_prev = frame->f_lasti; 
+    return result; 
+} 
+ 
 int
 _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
-{
+{ 
     assert(is_tstate_valid(tstate));
     /* The caller must hold the GIL */
     assert(PyGILState_Check());
@@ -4751,24 +4751,24 @@ _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
 
     PyObject *profileobj = tstate->c_profileobj;
 
-    tstate->c_profilefunc = NULL;
-    tstate->c_profileobj = NULL;
+    tstate->c_profilefunc = NULL; 
+    tstate->c_profileobj = NULL; 
     /* Must make sure that tracing is not ignored if 'profileobj' is freed */
-    tstate->use_tracing = tstate->c_tracefunc != NULL;
+    tstate->use_tracing = tstate->c_tracefunc != NULL; 
     Py_XDECREF(profileobj);
 
     Py_XINCREF(arg);
     tstate->c_profileobj = arg;
-    tstate->c_profilefunc = func;
+    tstate->c_profilefunc = func; 
 
-    /* Flag that tracing or profiling is turned on */
-    tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
+    /* Flag that tracing or profiling is turned on */ 
+    tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL); 
     return 0;
-}
-
-void
+} 
+ 
+void 
 PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
-{
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     if (_PyEval_SetProfile(tstate, func, arg) < 0) {
         /* Log _PySys_Audit() error */
@@ -4794,26 +4794,26 @@ _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
     PyObject *traceobj = tstate->c_traceobj;
     ceval2->tracing_possible += (func != NULL) - (tstate->c_tracefunc != NULL);
 
-    tstate->c_tracefunc = NULL;
-    tstate->c_traceobj = 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;
-    tstate->c_tracefunc = func;
+    tstate->c_tracefunc = func; 
 
-    /* Flag that tracing or profiling is turned on */
-    tstate->use_tracing = ((func != NULL)
-                           || (tstate->c_profilefunc != NULL));
+    /* Flag that tracing or profiling is turned on */ 
+    tstate->use_tracing = ((func != NULL) 
+                           || (tstate->c_profilefunc != NULL)); 
 
     return 0;
-}
-
-void
+} 
+ 
+void 
 PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
-{
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     if (_PyEval_SetTrace(tstate, func, arg) < 0) {
         /* Log _PySys_Audit() error */
@@ -4825,17 +4825,17 @@ PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
 void
 _PyEval_SetCoroutineOriginTrackingDepth(PyThreadState *tstate, int new_depth)
 {
-    assert(new_depth >= 0);
-    tstate->coroutine_origin_tracking_depth = new_depth;
-}
-
-int
-_PyEval_GetCoroutineOriginTrackingDepth(void)
-{
+    assert(new_depth >= 0); 
+    tstate->coroutine_origin_tracking_depth = new_depth; 
+} 
+ 
+int 
+_PyEval_GetCoroutineOriginTrackingDepth(void) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
-    return tstate->coroutine_origin_tracking_depth;
-}
-
+    return tstate->coroutine_origin_tracking_depth; 
+} 
+ 
 int
 _PyEval_SetAsyncGenFirstiter(PyObject *firstiter)
 {
@@ -4850,13 +4850,13 @@ _PyEval_SetAsyncGenFirstiter(PyObject *firstiter)
     return 0;
 }
 
-PyObject *
+PyObject * 
 _PyEval_GetAsyncGenFirstiter(void)
-{
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     return tstate->async_gen_firstiter;
-}
-
+} 
+ 
 int
 _PyEval_SetAsyncGenFinalizer(PyObject *finalizer)
 {
@@ -4871,159 +4871,159 @@ _PyEval_SetAsyncGenFinalizer(PyObject *finalizer)
     return 0;
 }
 
-PyObject *
+PyObject * 
 _PyEval_GetAsyncGenFinalizer(void)
-{
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     return tstate->async_gen_finalizer;
-}
-
+} 
+ 
 PyFrameObject *
 PyEval_GetFrame(void)
-{
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     return tstate->frame;
-}
-
-PyObject *
-PyEval_GetBuiltins(void)
-{
+} 
+ 
+PyObject * 
+PyEval_GetBuiltins(void) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     PyFrameObject *current_frame = tstate->frame;
-    if (current_frame == NULL)
+    if (current_frame == NULL) 
         return tstate->interp->builtins;
-    else
-        return current_frame->f_builtins;
-}
-
-/* Convenience function to get a builtin from its name */
-PyObject *
-_PyEval_GetBuiltinId(_Py_Identifier *name)
-{
+    else 
+        return current_frame->f_builtins; 
+} 
+ 
+/* Convenience function to get a builtin from its name */ 
+PyObject * 
+_PyEval_GetBuiltinId(_Py_Identifier *name) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
-    PyObject *attr = _PyDict_GetItemIdWithError(PyEval_GetBuiltins(), name);
-    if (attr) {
-        Py_INCREF(attr);
-    }
+    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));
-    }
-    return attr;
-}
-
-PyObject *
-PyEval_GetLocals(void)
-{
+    } 
+    return attr; 
+} 
+ 
+PyObject * 
+PyEval_GetLocals(void) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     PyFrameObject *current_frame = tstate->frame;
-    if (current_frame == NULL) {
+    if (current_frame == NULL) { 
         _PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist");
-        return NULL;
-    }
-
+        return NULL; 
+    } 
+ 
     if (PyFrame_FastToLocalsWithError(current_frame) < 0) {
-        return NULL;
-    }
-
-    assert(current_frame->f_locals != NULL);
-    return current_frame->f_locals;
-}
-
-PyObject *
-PyEval_GetGlobals(void)
-{
+        return NULL; 
+    }
+ 
+    assert(current_frame->f_locals != NULL); 
+    return current_frame->f_locals; 
+} 
+ 
+PyObject * 
+PyEval_GetGlobals(void) 
+{ 
     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;
-}
-
-int
-PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
-{
+        return NULL; 
+    }
+ 
+    assert(current_frame->f_globals != NULL); 
+    return current_frame->f_globals; 
+} 
+ 
+int 
+PyEval_MergeCompilerFlags(PyCompilerFlags *cf) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
     PyFrameObject *current_frame = tstate->frame;
-    int result = cf->cf_flags != 0;
-
-    if (current_frame != NULL) {
-        const int codeflags = current_frame->f_code->co_flags;
-        const int compilerflags = codeflags & PyCF_MASK;
-        if (compilerflags) {
-            result = 1;
-            cf->cf_flags |= compilerflags;
-        }
-#if 0 /* future keyword */
-        if (codeflags & CO_GENERATOR_ALLOWED) {
-            result = 1;
-            cf->cf_flags |= CO_GENERATOR_ALLOWED;
-        }
-#endif
-    }
-    return result;
-}
-
-
-const char *
-PyEval_GetFuncName(PyObject *func)
-{
-    if (PyMethod_Check(func))
-        return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
-    else if (PyFunction_Check(func))
-        return PyUnicode_AsUTF8(((PyFunctionObject*)func)->func_name);
-    else if (PyCFunction_Check(func))
-        return ((PyCFunctionObject*)func)->m_ml->ml_name;
-    else
+    int result = cf->cf_flags != 0; 
+ 
+    if (current_frame != NULL) { 
+        const int codeflags = current_frame->f_code->co_flags; 
+        const int compilerflags = codeflags & PyCF_MASK; 
+        if (compilerflags) { 
+            result = 1; 
+            cf->cf_flags |= compilerflags; 
+        } 
+#if 0 /* future keyword */ 
+        if (codeflags & CO_GENERATOR_ALLOWED) { 
+            result = 1; 
+            cf->cf_flags |= CO_GENERATOR_ALLOWED; 
+        } 
+#endif 
+    } 
+    return result; 
+} 
+ 
+ 
+const char * 
+PyEval_GetFuncName(PyObject *func) 
+{ 
+    if (PyMethod_Check(func)) 
+        return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func)); 
+    else if (PyFunction_Check(func)) 
+        return PyUnicode_AsUTF8(((PyFunctionObject*)func)->func_name); 
+    else if (PyCFunction_Check(func)) 
+        return ((PyCFunctionObject*)func)->m_ml->ml_name; 
+    else 
         return Py_TYPE(func)->tp_name;
-}
-
-const char *
-PyEval_GetFuncDesc(PyObject *func)
-{
-    if (PyMethod_Check(func))
-        return "()";
-    else if (PyFunction_Check(func))
-        return "()";
-    else if (PyCFunction_Check(func))
-        return "()";
-    else
-        return " object";
-}
-
-#define C_TRACE(x, call) \
-if (tstate->use_tracing && tstate->c_profilefunc) { \
-    if (call_trace(tstate->c_profilefunc, tstate->c_profileobj, \
-        tstate, tstate->frame, \
-        PyTrace_C_CALL, func)) { \
-        x = NULL; \
-    } \
-    else { \
-        x = call; \
-        if (tstate->c_profilefunc != NULL) { \
-            if (x == NULL) { \
-                call_trace_protected(tstate->c_profilefunc, \
-                    tstate->c_profileobj, \
-                    tstate, tstate->frame, \
-                    PyTrace_C_EXCEPTION, func); \
-                /* XXX should pass (type, value, tb) */ \
-            } else { \
-                if (call_trace(tstate->c_profilefunc, \
-                    tstate->c_profileobj, \
-                    tstate, tstate->frame, \
-                    PyTrace_C_RETURN, func)) { \
-                    Py_DECREF(x); \
-                    x = NULL; \
-                } \
-            } \
-        } \
-    } \
-} else { \
-    x = call; \
-    }
-
+} 
+ 
+const char * 
+PyEval_GetFuncDesc(PyObject *func) 
+{ 
+    if (PyMethod_Check(func)) 
+        return "()"; 
+    else if (PyFunction_Check(func)) 
+        return "()"; 
+    else if (PyCFunction_Check(func)) 
+        return "()"; 
+    else 
+        return " object"; 
+} 
+ 
+#define C_TRACE(x, call) \ 
+if (tstate->use_tracing && tstate->c_profilefunc) { \ 
+    if (call_trace(tstate->c_profilefunc, tstate->c_profileobj, \ 
+        tstate, tstate->frame, \ 
+        PyTrace_C_CALL, func)) { \ 
+        x = NULL; \ 
+    } \ 
+    else { \ 
+        x = call; \ 
+        if (tstate->c_profilefunc != NULL) { \ 
+            if (x == NULL) { \ 
+                call_trace_protected(tstate->c_profilefunc, \ 
+                    tstate->c_profileobj, \ 
+                    tstate, tstate->frame, \ 
+                    PyTrace_C_EXCEPTION, func); \ 
+                /* XXX should pass (type, value, tb) */ \ 
+            } else { \ 
+                if (call_trace(tstate->c_profilefunc, \ 
+                    tstate->c_profileobj, \ 
+                    tstate, tstate->frame, \ 
+                    PyTrace_C_RETURN, func)) { \ 
+                    Py_DECREF(x); \ 
+                    x = NULL; \ 
+                } \ 
+            } \ 
+        } \ 
+    } \ 
+} else { \ 
+    x = call; \ 
+    } 
+ 
 
 static PyObject *
 trace_call_function(PyThreadState *tstate,
@@ -5058,45 +5058,45 @@ trace_call_function(PyThreadState *tstate,
     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
+/* 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)
-{
-    PyObject **pfunc = (*pp_stack) - oparg - 1;
-    PyObject *func = *pfunc;
-    PyObject *x, *w;
-    Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
-    Py_ssize_t nargs = oparg - nkwargs;
-    PyObject **stack = (*pp_stack) - nargs - nkwargs;
-
+{ 
+    PyObject **pfunc = (*pp_stack) - oparg - 1; 
+    PyObject *func = *pfunc; 
+    PyObject *x, *w; 
+    Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames); 
+    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);
-    }
-    else {
+    } 
+    else { 
         x = PyObject_Vectorcall(func, stack, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
-    }
-
+    } 
+ 
     assert((x != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
-
-    /* Clear the stack of the function object. */
-    while ((*pp_stack) > pfunc) {
-        w = EXT_POP(*pp_stack);
-        Py_DECREF(w);
-    }
-
-    return x;
-}
-
-static PyObject *
+ 
+    /* Clear the stack of the function object. */ 
+    while ((*pp_stack) > pfunc) { 
+        w = EXT_POP(*pp_stack); 
+        Py_DECREF(w); 
+    } 
+ 
+    return x; 
+} 
+ 
+static PyObject * 
 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));
-        return result;
-    }
+        return result; 
+    } 
     else if (Py_IS_TYPE(func, &PyMethodDescr_Type)) {
         Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
         if (nargs > 0 && tstate->use_tracing) {
@@ -5121,155 +5121,155 @@ do_call_core(PyThreadState *tstate, PyObject *func, PyObject *callargs, PyObject
             Py_DECREF(func);
             return result;
         }
-    }
+    } 
     return PyObject_Call(func, callargs, kwdict);
-}
-
-/* Extract a slice index from a PyLong or an object with the
-   nb_index slot defined, and store in *pi.
-   Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
-   and silently boost values less than PY_SSIZE_T_MIN to PY_SSIZE_T_MIN.
-   Return 0 on error, 1 on success.
-*/
-int
-_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
-{
+} 
+ 
+/* Extract a slice index from a PyLong or an object with the 
+   nb_index slot defined, and store in *pi. 
+   Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX, 
+   and silently boost values less than PY_SSIZE_T_MIN to PY_SSIZE_T_MIN. 
+   Return 0 on error, 1 on success. 
+*/ 
+int 
+_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
-    if (v != Py_None) {
-        Py_ssize_t x;
+    if (v != Py_None) { 
+        Py_ssize_t x; 
         if (_PyIndex_Check(v)) {
-            x = PyNumber_AsSsize_t(v, NULL);
+            x = PyNumber_AsSsize_t(v, NULL); 
             if (x == -1 && _PyErr_Occurred(tstate))
-                return 0;
-        }
-        else {
+                return 0; 
+        } 
+        else { 
             _PyErr_SetString(tstate, PyExc_TypeError,
                              "slice indices must be integers or "
                              "None or have an __index__ method");
-            return 0;
-        }
-        *pi = x;
-    }
-    return 1;
-}
-
-int
-_PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
-{
+            return 0; 
+        } 
+        *pi = x; 
+    } 
+    return 1; 
+} 
+ 
+int 
+_PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi) 
+{ 
     PyThreadState *tstate = _PyThreadState_GET();
-    Py_ssize_t x;
+    Py_ssize_t x; 
     if (_PyIndex_Check(v)) {
-        x = PyNumber_AsSsize_t(v, NULL);
+        x = PyNumber_AsSsize_t(v, NULL); 
         if (x == -1 && _PyErr_Occurred(tstate))
-            return 0;
-    }
-    else {
+            return 0; 
+    } 
+    else { 
         _PyErr_SetString(tstate, PyExc_TypeError,
                          "slice indices must be integers or "
                          "have an __index__ method");
-        return 0;
-    }
-    *pi = x;
-    return 1;
-}
-
-static PyObject *
+        return 0; 
+    } 
+    *pi = x; 
+    return 1; 
+} 
+ 
+static PyObject * 
 import_name(PyThreadState *tstate, PyFrameObject *f,
             PyObject *name, PyObject *fromlist, PyObject *level)
-{
-    _Py_IDENTIFIER(__import__);
-    PyObject *import_func, *res;
-    PyObject* stack[5];
-
+{ 
+    _Py_IDENTIFIER(__import__); 
+    PyObject *import_func, *res; 
+    PyObject* stack[5]; 
+ 
     import_func = _PyDict_GetItemIdWithError(f->f_builtins, &PyId___import__);
-    if (import_func == NULL) {
+    if (import_func == NULL) { 
         if (!_PyErr_Occurred(tstate)) {
             _PyErr_SetString(tstate, PyExc_ImportError, "__import__ not found");
         }
-        return NULL;
-    }
-
-    /* Fast path for not overloaded __import__. */
+        return NULL; 
+    } 
+ 
+    /* Fast path for not overloaded __import__. */ 
     if (import_func == tstate->interp->import_func) {
-        int ilevel = _PyLong_AsInt(level);
+        int ilevel = _PyLong_AsInt(level); 
         if (ilevel == -1 && _PyErr_Occurred(tstate)) {
-            return NULL;
-        }
-        res = PyImport_ImportModuleLevelObject(
-                        name,
-                        f->f_globals,
-                        f->f_locals == NULL ? Py_None : f->f_locals,
-                        fromlist,
-                        ilevel);
-        return res;
-    }
-
-    Py_INCREF(import_func);
-
-    stack[0] = name;
-    stack[1] = f->f_globals;
-    stack[2] = f->f_locals == NULL ? Py_None : f->f_locals;
-    stack[3] = fromlist;
-    stack[4] = level;
-    res = _PyObject_FastCall(import_func, stack, 5);
-    Py_DECREF(import_func);
-    return res;
-}
-
-static PyObject *
+            return NULL; 
+        } 
+        res = PyImport_ImportModuleLevelObject( 
+                        name, 
+                        f->f_globals, 
+                        f->f_locals == NULL ? Py_None : f->f_locals, 
+                        fromlist, 
+                        ilevel); 
+        return res; 
+    } 
+ 
+    Py_INCREF(import_func); 
+ 
+    stack[0] = name; 
+    stack[1] = f->f_globals; 
+    stack[2] = f->f_locals == NULL ? Py_None : f->f_locals; 
+    stack[3] = fromlist; 
+    stack[4] = level; 
+    res = _PyObject_FastCall(import_func, stack, 5); 
+    Py_DECREF(import_func); 
+    return res; 
+} 
+ 
+static PyObject * 
 import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
-{
-    PyObject *x;
-    PyObject *fullmodname, *pkgname, *pkgpath, *pkgname_or_unknown, *errmsg;
-
-    if (_PyObject_LookupAttr(v, name, &x) != 0) {
-        return x;
-    }
-    /* Issue #17636: in case this failed because of a circular relative
-       import, try to fallback on reading the module directly from
-       sys.modules. */
-    pkgname = _PyObject_GetAttrId(v, &PyId___name__);
-    if (pkgname == NULL) {
-        goto error;
-    }
-    if (!PyUnicode_Check(pkgname)) {
-        Py_CLEAR(pkgname);
-        goto error;
-    }
-    fullmodname = PyUnicode_FromFormat("%U.%U", pkgname, name);
-    if (fullmodname == NULL) {
-        Py_DECREF(pkgname);
-        return NULL;
-    }
-    x = PyImport_GetModule(fullmodname);
-    Py_DECREF(fullmodname);
+{ 
+    PyObject *x; 
+    PyObject *fullmodname, *pkgname, *pkgpath, *pkgname_or_unknown, *errmsg; 
+ 
+    if (_PyObject_LookupAttr(v, name, &x) != 0) { 
+        return x; 
+    } 
+    /* Issue #17636: in case this failed because of a circular relative 
+       import, try to fallback on reading the module directly from 
+       sys.modules. */ 
+    pkgname = _PyObject_GetAttrId(v, &PyId___name__); 
+    if (pkgname == NULL) { 
+        goto error; 
+    } 
+    if (!PyUnicode_Check(pkgname)) { 
+        Py_CLEAR(pkgname); 
+        goto error; 
+    } 
+    fullmodname = PyUnicode_FromFormat("%U.%U", pkgname, name); 
+    if (fullmodname == NULL) { 
+        Py_DECREF(pkgname); 
+        return NULL; 
+    } 
+    x = PyImport_GetModule(fullmodname); 
+    Py_DECREF(fullmodname); 
     if (x == NULL && !_PyErr_Occurred(tstate)) {
-        goto error;
-    }
-    Py_DECREF(pkgname);
-    return x;
- error:
-    pkgpath = PyModule_GetFilenameObject(v);
-    if (pkgname == NULL) {
-        pkgname_or_unknown = PyUnicode_FromString("<unknown module name>");
-        if (pkgname_or_unknown == NULL) {
-            Py_XDECREF(pkgpath);
-            return NULL;
-        }
-    } else {
-        pkgname_or_unknown = pkgname;
-    }
-
-    if (pkgpath == NULL || !PyUnicode_Check(pkgpath)) {
+        goto error; 
+    } 
+    Py_DECREF(pkgname); 
+    return x; 
+ error: 
+    pkgpath = PyModule_GetFilenameObject(v); 
+    if (pkgname == NULL) { 
+        pkgname_or_unknown = PyUnicode_FromString("<unknown module name>"); 
+        if (pkgname_or_unknown == NULL) { 
+            Py_XDECREF(pkgpath); 
+            return NULL; 
+        } 
+    } else { 
+        pkgname_or_unknown = pkgname; 
+    } 
+ 
+    if (pkgpath == NULL || !PyUnicode_Check(pkgpath)) { 
         _PyErr_Clear(tstate);
-        errmsg = PyUnicode_FromFormat(
-            "cannot import name %R from %R (unknown location)",
-            name, pkgname_or_unknown
-        );
+        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. */
-        PyErr_SetImportError(errmsg, pkgname, NULL);
-    }
-    else {
+        PyErr_SetImportError(errmsg, pkgname, NULL); 
+    } 
+    else { 
         _Py_IDENTIFIER(__spec__);
         PyObject *spec = _PyObject_GetAttrId(v, &PyId___spec__);
         const char *fmt =
@@ -5281,54 +5281,54 @@ import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
 
         errmsg = PyUnicode_FromFormat(fmt, name, pkgname_or_unknown, pkgpath);
         /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
-        PyErr_SetImportError(errmsg, pkgname, pkgpath);
-    }
-
-    Py_XDECREF(errmsg);
-    Py_XDECREF(pkgname_or_unknown);
-    Py_XDECREF(pkgpath);
-    return NULL;
-}
-
-static int
+        PyErr_SetImportError(errmsg, pkgname, pkgpath); 
+    } 
+ 
+    Py_XDECREF(errmsg); 
+    Py_XDECREF(pkgname_or_unknown); 
+    Py_XDECREF(pkgpath); 
+    return NULL; 
+} 
+ 
+static int 
 import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
-{
-    _Py_IDENTIFIER(__all__);
-    _Py_IDENTIFIER(__dict__);
-    PyObject *all, *dict, *name, *value;
-    int skip_leading_underscores = 0;
-    int pos, err;
-
-    if (_PyObject_LookupAttrId(v, &PyId___all__, &all) < 0) {
-        return -1; /* Unexpected error */
-    }
-    if (all == NULL) {
-        if (_PyObject_LookupAttrId(v, &PyId___dict__, &dict) < 0) {
-            return -1;
-        }
-        if (dict == NULL) {
+{ 
+    _Py_IDENTIFIER(__all__); 
+    _Py_IDENTIFIER(__dict__); 
+    PyObject *all, *dict, *name, *value; 
+    int skip_leading_underscores = 0; 
+    int pos, err; 
+ 
+    if (_PyObject_LookupAttrId(v, &PyId___all__, &all) < 0) { 
+        return -1; /* Unexpected error */ 
+    } 
+    if (all == NULL) { 
+        if (_PyObject_LookupAttrId(v, &PyId___dict__, &dict) < 0) { 
+            return -1; 
+        } 
+        if (dict == NULL) { 
             _PyErr_SetString(tstate, PyExc_ImportError,
-                    "from-import-* object has no __dict__ and no __all__");
-            return -1;
-        }
-        all = PyMapping_Keys(dict);
-        Py_DECREF(dict);
-        if (all == NULL)
-            return -1;
-        skip_leading_underscores = 1;
-    }
-
-    for (pos = 0, err = 0; ; pos++) {
-        name = PySequence_GetItem(all, pos);
-        if (name == NULL) {
+                    "from-import-* object has no __dict__ and no __all__"); 
+            return -1; 
+        } 
+        all = PyMapping_Keys(dict); 
+        Py_DECREF(dict); 
+        if (all == NULL) 
+            return -1; 
+        skip_leading_underscores = 1; 
+    } 
+ 
+    for (pos = 0, err = 0; ; pos++) { 
+        name = PySequence_GetItem(all, pos); 
+        if (name == NULL) { 
             if (!_PyErr_ExceptionMatches(tstate, PyExc_IndexError)) {
-                err = -1;
+                err = -1; 
             }
             else {
                 _PyErr_Clear(tstate);
             }
-            break;
-        }
+            break; 
+        } 
         if (!PyUnicode_Check(name)) {
             PyObject *modname = _PyObject_GetAttrId(v, &PyId___name__);
             if (modname == NULL) {
@@ -5355,35 +5355,35 @@ import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
             break;
         }
         if (skip_leading_underscores) {
-            if (PyUnicode_READY(name) == -1) {
-                Py_DECREF(name);
-                err = -1;
-                break;
-            }
-            if (PyUnicode_READ_CHAR(name, 0) == '_') {
-                Py_DECREF(name);
-                continue;
-            }
-        }
-        value = PyObject_GetAttr(v, name);
-        if (value == NULL)
-            err = -1;
-        else if (PyDict_CheckExact(locals))
-            err = PyDict_SetItem(locals, name, value);
-        else
-            err = PyObject_SetItem(locals, name, value);
-        Py_DECREF(name);
-        Py_XDECREF(value);
-        if (err != 0)
-            break;
-    }
-    Py_DECREF(all);
-    return err;
-}
-
-static int
+            if (PyUnicode_READY(name) == -1) { 
+                Py_DECREF(name); 
+                err = -1; 
+                break; 
+            } 
+            if (PyUnicode_READ_CHAR(name, 0) == '_') { 
+                Py_DECREF(name); 
+                continue; 
+            } 
+        } 
+        value = PyObject_GetAttr(v, name); 
+        if (value == NULL) 
+            err = -1; 
+        else if (PyDict_CheckExact(locals)) 
+            err = PyDict_SetItem(locals, name, value); 
+        else 
+            err = PyObject_SetItem(locals, name, value); 
+        Py_DECREF(name); 
+        Py_XDECREF(value); 
+        if (err != 0) 
+            break; 
+    } 
+    Py_DECREF(all); 
+    return err; 
+} 
+ 
+static int 
 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
@@ -5396,14 +5396,14 @@ check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args)
                           funcstr, Py_TYPE(args)->tp_name);
             Py_DECREF(funcstr);
         }
-        return -1;
-    }
-    return 0;
-}
-
-static void
+        return -1; 
+    } 
+    return 0; 
+} 
+ 
+static void 
 format_kwargs_error(PyThreadState *tstate, PyObject *func, PyObject *kwargs)
-{
+{ 
     /* _PyDict_MergeEx raises attribute
      * error (percolated from an attempt
      * to get 'keys' attribute) instead of
@@ -5443,103 +5443,103 @@ format_kwargs_error(PyThreadState *tstate, PyObject *func, PyObject *kwargs)
             _PyErr_Restore(tstate, exc, val, tb);
         }
     }
-}
-
-static void
+} 
+ 
+static void 
 format_exc_check_arg(PyThreadState *tstate, PyObject *exc,
                      const char *format_str, PyObject *obj)
-{
-    const char *obj_str;
-
-    if (!obj)
-        return;
-
-    obj_str = PyUnicode_AsUTF8(obj);
-    if (!obj_str)
-        return;
-
+{ 
+    const char *obj_str; 
+ 
+    if (!obj) 
+        return; 
+ 
+    obj_str = PyUnicode_AsUTF8(obj); 
+    if (!obj_str) 
+        return; 
+ 
     _PyErr_Format(tstate, exc, format_str, obj_str);
-}
-
-static void
+} 
+ 
+static void 
 format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg)
-{
-    PyObject *name;
-    /* Don't stomp existing exception */
+{ 
+    PyObject *name; 
+    /* Don't stomp existing exception */ 
     if (_PyErr_Occurred(tstate))
-        return;
-    if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
-        name = PyTuple_GET_ITEM(co->co_cellvars,
-                                oparg);
+        return; 
+    if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) { 
+        name = PyTuple_GET_ITEM(co->co_cellvars, 
+                                oparg); 
         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));
+            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,
-                             UNBOUNDFREE_ERROR_MSG, name);
-    }
-}
-
-static void
+                             UNBOUNDFREE_ERROR_MSG, name); 
+    } 
+} 
+ 
+static void 
 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) {
+{ 
+    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);
-        }
+        } 
         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 *
+        } 
+    } 
+} 
+ 
+static PyObject * 
 unicode_concatenate(PyThreadState *tstate, PyObject *v, PyObject *w,
-                    PyFrameObject *f, const _Py_CODEUNIT *next_instr)
-{
-    PyObject *res;
-    if (Py_REFCNT(v) == 2) {
-        /* In the common case, there are 2 references to the value
-         * stored in 'variable' when the += is performed: one on the
-         * value stack (in 'v') and one still stored in the
-         * 'variable'.  We try to delete the variable now to reduce
-         * the refcnt to 1.
-         */
-        int opcode, oparg;
-        NEXTOPARG();
-        switch (opcode) {
-        case STORE_FAST:
-        {
-            PyObject **fastlocals = f->f_localsplus;
-            if (GETLOCAL(oparg) == v)
-                SETLOCAL(oparg, NULL);
-            break;
-        }
-        case STORE_DEREF:
-        {
-            PyObject **freevars = (f->f_localsplus +
-                                   f->f_code->co_nlocals);
-            PyObject *c = freevars[oparg];
-            if (PyCell_GET(c) ==  v) {
-                PyCell_SET(c, NULL);
-                Py_DECREF(v);
-            }
-            break;
-        }
-        case STORE_NAME:
-        {
-            PyObject *names = f->f_code->co_names;
-            PyObject *name = GETITEM(names, oparg);
-            PyObject *locals = f->f_locals;
+                    PyFrameObject *f, const _Py_CODEUNIT *next_instr) 
+{ 
+    PyObject *res; 
+    if (Py_REFCNT(v) == 2) { 
+        /* In the common case, there are 2 references to the value 
+         * stored in 'variable' when the += is performed: one on the 
+         * value stack (in 'v') and one still stored in the 
+         * 'variable'.  We try to delete the variable now to reduce 
+         * the refcnt to 1. 
+         */ 
+        int opcode, oparg; 
+        NEXTOPARG(); 
+        switch (opcode) { 
+        case STORE_FAST: 
+        { 
+            PyObject **fastlocals = f->f_localsplus; 
+            if (GETLOCAL(oparg) == v) 
+                SETLOCAL(oparg, NULL); 
+            break; 
+        } 
+        case STORE_DEREF: 
+        { 
+            PyObject **freevars = (f->f_localsplus + 
+                                   f->f_code->co_nlocals); 
+            PyObject *c = freevars[oparg]; 
+            if (PyCell_GET(c) ==  v) { 
+                PyCell_SET(c, NULL); 
+                Py_DECREF(v); 
+            } 
+            break; 
+        } 
+        case STORE_NAME: 
+        { 
+            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) ||
@@ -5547,138 +5547,138 @@ unicode_concatenate(PyThreadState *tstate, PyObject *v, PyObject *w,
                 {
                     Py_DECREF(v);
                     return NULL;
-                }
-            }
-            break;
-        }
-        }
-    }
-    res = v;
-    PyUnicode_Append(&res, w);
-    return res;
-}
-
-#ifdef DYNAMIC_EXECUTION_PROFILE
-
-static PyObject *
-getarray(long a[256])
-{
-    int i;
-    PyObject *l = PyList_New(256);
-    if (l == NULL) return NULL;
-    for (i = 0; i < 256; i++) {
-        PyObject *x = PyLong_FromLong(a[i]);
-        if (x == NULL) {
-            Py_DECREF(l);
-            return NULL;
-        }
-        PyList_SET_ITEM(l, i, x);
-    }
-    for (i = 0; i < 256; i++)
-        a[i] = 0;
-    return l;
-}
-
-PyObject *
-_Py_GetDXProfile(PyObject *self, PyObject *args)
-{
-#ifndef DXPAIRS
-    return getarray(dxp);
-#else
-    int i;
-    PyObject *l = PyList_New(257);
-    if (l == NULL) return NULL;
-    for (i = 0; i < 257; i++) {
-        PyObject *x = getarray(dxpairs[i]);
-        if (x == NULL) {
-            Py_DECREF(l);
-            return NULL;
-        }
-        PyList_SET_ITEM(l, i, x);
-    }
-    return l;
-#endif
-}
-
-#endif
-
-Py_ssize_t
-_PyEval_RequestCodeExtraIndex(freefunc free)
-{
+                } 
+            } 
+            break; 
+        } 
+        } 
+    } 
+    res = v; 
+    PyUnicode_Append(&res, w); 
+    return res; 
+} 
+ 
+#ifdef DYNAMIC_EXECUTION_PROFILE 
+ 
+static PyObject * 
+getarray(long a[256]) 
+{ 
+    int i; 
+    PyObject *l = PyList_New(256); 
+    if (l == NULL) return NULL; 
+    for (i = 0; i < 256; i++) { 
+        PyObject *x = PyLong_FromLong(a[i]); 
+        if (x == NULL) { 
+            Py_DECREF(l); 
+            return NULL; 
+        } 
+        PyList_SET_ITEM(l, i, x); 
+    } 
+    for (i = 0; i < 256; i++) 
+        a[i] = 0; 
+    return l; 
+} 
+ 
+PyObject * 
+_Py_GetDXProfile(PyObject *self, PyObject *args) 
+{ 
+#ifndef DXPAIRS 
+    return getarray(dxp); 
+#else 
+    int i; 
+    PyObject *l = PyList_New(257); 
+    if (l == NULL) return NULL; 
+    for (i = 0; i < 257; i++) { 
+        PyObject *x = getarray(dxpairs[i]); 
+        if (x == NULL) { 
+            Py_DECREF(l); 
+            return NULL; 
+        } 
+        PyList_SET_ITEM(l, i, x); 
+    } 
+    return l; 
+#endif 
+} 
+ 
+#endif 
+ 
+Py_ssize_t 
+_PyEval_RequestCodeExtraIndex(freefunc free) 
+{ 
     PyInterpreterState *interp = _PyInterpreterState_GET();
-    Py_ssize_t new_index;
-
-    if (interp->co_extra_user_count == MAX_CO_EXTRA_USERS - 1) {
-        return -1;
-    }
-    new_index = interp->co_extra_user_count++;
-    interp->co_extra_freefuncs[new_index] = free;
-    return new_index;
-}
-
-static void
-dtrace_function_entry(PyFrameObject *f)
-{
-    const char *filename;
-    const char *funcname;
-    int lineno;
-
+    Py_ssize_t new_index; 
+ 
+    if (interp->co_extra_user_count == MAX_CO_EXTRA_USERS - 1) { 
+        return -1; 
+    } 
+    new_index = interp->co_extra_user_count++; 
+    interp->co_extra_freefuncs[new_index] = free; 
+    return new_index; 
+} 
+ 
+static void 
+dtrace_function_entry(PyFrameObject *f) 
+{ 
+    const char *filename; 
+    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);
-
-    PyDTrace_FUNCTION_ENTRY(filename, funcname, lineno);
-}
-
-static void
-dtrace_function_return(PyFrameObject *f)
-{
-    const char *filename;
-    const char *funcname;
-    int lineno;
-
+ 
+    PyDTrace_FUNCTION_ENTRY(filename, funcname, lineno); 
+} 
+ 
+static void 
+dtrace_function_return(PyFrameObject *f) 
+{ 
+    const char *filename; 
+    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);
-
-    PyDTrace_FUNCTION_RETURN(filename, funcname, lineno);
-}
-
-/* DTrace equivalent of maybe_call_line_trace. */
-static void
-maybe_dtrace_line(PyFrameObject *frame,
-                  int *instr_lb, int *instr_ub, int *instr_prev)
-{
-    int line = frame->f_lineno;
-    const char *co_filename, *co_name;
-
-    /* If the last instruction executed isn't in the current
-       instruction window, reset the window.
-    */
-    if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) {
-        PyAddrPair bounds;
-        line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
-                                       &bounds);
-        *instr_lb = bounds.ap_lower;
-        *instr_ub = bounds.ap_upper;
-    }
-    /* If the last instruction falls at the start of a line or if
-       it represents a jump backwards, update the frame's line
-       number and call the trace function. */
-    if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) {
-        frame->f_lineno = line;
-        co_filename = PyUnicode_AsUTF8(frame->f_code->co_filename);
-        if (!co_filename)
-            co_filename = "?";
-        co_name = PyUnicode_AsUTF8(frame->f_code->co_name);
-        if (!co_name)
-            co_name = "?";
-        PyDTrace_LINE(co_filename, co_name, line);
-    }
-    *instr_prev = frame->f_lasti;
-}
+ 
+    PyDTrace_FUNCTION_RETURN(filename, funcname, lineno); 
+} 
+ 
+/* DTrace equivalent of maybe_call_line_trace. */ 
+static void 
+maybe_dtrace_line(PyFrameObject *frame, 
+                  int *instr_lb, int *instr_ub, int *instr_prev) 
+{ 
+    int line = frame->f_lineno; 
+    const char *co_filename, *co_name; 
+ 
+    /* If the last instruction executed isn't in the current 
+       instruction window, reset the window. 
+    */ 
+    if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) { 
+        PyAddrPair bounds; 
+        line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti, 
+                                       &bounds); 
+        *instr_lb = bounds.ap_lower; 
+        *instr_ub = bounds.ap_upper; 
+    } 
+    /* If the last instruction falls at the start of a line or if 
+       it represents a jump backwards, update the frame's line 
+       number and call the trace function. */ 
+    if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) { 
+        frame->f_lineno = line; 
+        co_filename = PyUnicode_AsUTF8(frame->f_code->co_filename); 
+        if (!co_filename) 
+            co_filename = "?"; 
+        co_name = PyUnicode_AsUTF8(frame->f_code->co_name); 
+        if (!co_name) 
+            co_name = "?"; 
+        PyDTrace_LINE(co_filename, co_name, line); 
+    } 
+    *instr_prev = frame->f_lasti; 
+} 
 
 
 /* Implement Py_EnterRecursiveCall() and Py_LeaveRecursiveCall() as functions