LCOV - code coverage report
Current view: | top level - Python - bytecodes.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 1122 | 1409 | 79.6 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 0 | 0 | -
|  |  | Branches: | 743 | 1233 | 60.3 %

               Branch data     Line data    Source code
           1                 :            : // This file contains instruction definitions.
           2                 :            : // It is read by Tools/cases_generator/generate_cases.py
           3                 :            : // to generate Python/generated_cases.c.h.
           4                 :            : // Note that there is some dummy C code at the top and bottom of the file
           5                 :            : // to fool text editors like VS Code into believing this is valid C code.
           6                 :            : // The actual instruction definitions start at // BEGIN BYTECODES //.
           7                 :            : // See Tools/cases_generator/README.md for more information.
           8                 :            :
           9                 :            : #include "Python.h"
          10                 :            : #include "pycore_abstract.h"      // _PyIndex_Check()
          11                 :            : #include "pycore_call.h"          // _PyObject_FastCallDictTstate()
          12                 :            : #include "pycore_ceval.h"         // _PyEval_SignalAsyncExc()
          13                 :            : #include "pycore_code.h"
          14                 :            : #include "pycore_function.h"
          15                 :            : #include "pycore_intrinsics.h"
          16                 :            : #include "pycore_long.h"          // _PyLong_GetZero()
          17                 :            : #include "pycore_object.h"        // _PyObject_GC_TRACK()
          18                 :            : #include "pycore_moduleobject.h"  // PyModuleObject
          19                 :            : #include "pycore_opcode.h"        // EXTRA_CASES
          20                 :            : #include "pycore_pyerrors.h"      // _PyErr_GetRaisedException()
          21                 :            : #include "pycore_pymem.h"         // _PyMem_IsPtrFreed()
          22                 :            : #include "pycore_pystate.h"       // _PyInterpreterState_GET()
          23                 :            : #include "pycore_range.h"         // _PyRangeIterObject
          24                 :            : #include "pycore_sliceobject.h"   // _PyBuildSlice_ConsumeRefs
          25                 :            : #include "pycore_sysmodule.h"     // _PySys_Audit()
          26                 :            : #include "pycore_tuple.h"         // _PyTuple_ITEMS()
          27                 :            : #include "pycore_emscripten_signal.h"  // _Py_CHECK_EMSCRIPTEN_SIGNALS
          28                 :            :
          29                 :            : #include "pycore_dict.h"
          30                 :            : #include "dictobject.h"
          31                 :            : #include "pycore_frame.h"
          32                 :            : #include "opcode.h"
          33                 :            : #include "pydtrace.h"
          34                 :            : #include "setobject.h"
          35                 :            : #include "structmember.h"         // struct PyMemberDef, T_OFFSET_EX
          36                 :            :
          37                 :            : #define USE_COMPUTED_GOTOS 0
          38                 :            : #include "ceval_macros.h"
          39                 :            :
          40                 :            : /* Flow control macros */
          41                 :            : #define DEOPT_IF(cond, instname) ((void)0)
          42                 :            : #define ERROR_IF(cond, labelname) ((void)0)
          43                 :            : #define GO_TO_INSTRUCTION(instname) ((void)0)
          44                 :            : #define PREDICT(opname) ((void)0)
          45                 :            :
          46                 :            : #define inst(name, ...) case name:
          47                 :            : #define op(name, ...) /* NAME is ignored */
          48                 :            : #define macro(name) static int MACRO_##name
          49                 :            : #define super(name) static int SUPER_##name
          50                 :            : #define family(name, ...) static int family_##name
          51                 :            :
          52                 :            : // Dummy variables for stack effects.
          53                 :            : static PyObject *value, *value1, *value2, *left, *right, *res, *sum, *prod, *sub;
          54                 :            : static PyObject *container, *start, *stop, *v, *lhs, *rhs, *res2;
          55                 :            : static PyObject *list, *tuple, *dict, *owner, *set, *str, *tup, *map, *keys;
          56                 :            : static PyObject *exit_func, *lasti, *val, *retval, *obj, *iter;
          57                 :            : static PyObject *aiter, *awaitable, *iterable, *w, *exc_value, *bc;
          58                 :            : static PyObject *orig, *excs, *update, *b, *fromlist, *level, *from;
          59                 :            : static PyObject **pieces, **values;
          60                 :            : static size_t jump;
          61                 :            : // Dummy variables for cache effects
          62                 :            : static uint16_t invert, counter, index, hint;
          63                 :            : static uint32_t type_version;
          64                 :            :
          65                 :            : static PyObject *
          66                 :            : dummy_func(
          67                 :            :     PyThreadState *tstate,
          68                 :            :     _PyInterpreterFrame *frame,
          69                 :            :     unsigned char opcode,
          70                 :            :     unsigned int oparg,
          71                 :            :     _Py_atomic_int * const eval_breaker,
          72                 :            :     _PyCFrame cframe,
          73                 :            :     _Py_CODEUNIT *next_instr,
          74                 :            :     PyObject **stack_pointer,
          75                 :            :     PyObject *kwnames,
          76                 :            :     int throwflag,
          77                 :            :     binaryfunc binary_ops[]
          78                 :            : )
          79                 :            : {
          80                 :            :     _PyInterpreterFrame  entry_frame;
          81                 :            :
          82                 :            :     switch (opcode) {
          83                 :            :
          84                 :            : // BEGIN BYTECODES //
          85                 :            :         inst(NOP, (--)) {
          86                 :            :         }
          87                 :            :
          88                 :            :         inst(RESUME, (--)) {
          89                 :            :             assert(tstate->cframe == &cframe);
          90                 :            :             assert(frame == cframe.current_frame);
          91   [ +  +  +  - ]:    4035495 :             if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {
          92                 :         59 :                 goto handle_eval_breaker;
          93                 :            :             }
          94                 :            :         }
          95                 :            :
          96                 :            :         inst(LOAD_CLOSURE, (-- value)) {
          97                 :            :             /* We keep LOAD_CLOSURE so that the bytecode stays more readable. */
          98                 :      46173 :             value = GETLOCAL(oparg);
          99         [ -  + ]:      46173 :             ERROR_IF(value == NULL, unbound_local_error);
         100                 :      46173 :             Py_INCREF(value);
         101                 :            :         }
         102                 :            :
         103                 :            :         inst(LOAD_FAST_CHECK, (-- value)) {
         104                 :       3012 :             value = GETLOCAL(oparg);
         105         [ -  + ]:       3012 :             ERROR_IF(value == NULL, unbound_local_error);
         106                 :       3012 :             Py_INCREF(value);
         107                 :            :         }
         108                 :            :
         109                 :            :         inst(LOAD_FAST, (-- value)) {
         110                 :   36525549 :             value = GETLOCAL(oparg);
         111                 :            :             assert(value != NULL);
         112                 :   29914039 :             Py_INCREF(value);
         113                 :            :         }
         114                 :            :
         115                 :            :         inst(LOAD_CONST, (-- value)) {
         116                 :    5687217 :             value = GETITEM(frame->f_code->co_consts, oparg);
         117                 :    5687217 :             Py_INCREF(value);
         118                 :            :         }
         119                 :            :
         120                 :            :         inst(STORE_FAST, (value --)) {
         121   [ +  +  +  +  :   10025372 :             SETLOCAL(oparg, value);
              +  +  +  +  +
              +  +  +  +  +
                       +  + ]
         122                 :            :         }
         123                 :            :
         124                 :            :         super(LOAD_FAST__LOAD_FAST) = LOAD_FAST + LOAD_FAST;
         125                 :            :         super(LOAD_FAST__LOAD_CONST) = LOAD_FAST + LOAD_CONST;
         126                 :            :         super(STORE_FAST__LOAD_FAST)  = STORE_FAST + LOAD_FAST;
         127                 :            :         super(STORE_FAST__STORE_FAST) = STORE_FAST + STORE_FAST;
         128                 :            :         super(LOAD_CONST__LOAD_FAST) = LOAD_CONST + LOAD_FAST;
         129                 :            :
         130                 :            :         inst(POP_TOP, (value --)) {
         131                 :            :             DECREF_INPUTS();
         132                 :            :         }
         133                 :            :
         134                 :            :         inst(PUSH_NULL, (-- res)) {
         135                 :    1841863 :             res = NULL;
         136                 :            :         }
         137                 :            :
         138                 :            :         macro(END_FOR) = POP_TOP + POP_TOP;
         139                 :            :
         140                 :            :         inst(UNARY_NEGATIVE, (value -- res)) {
         141                 :      45079 :             res = PyNumber_Negative(value);
         142                 :            :             DECREF_INPUTS();
         143         [ -  + ]:      45079 :             ERROR_IF(res == NULL, error);
         144                 :            :         }
         145                 :            :
         146                 :            :         inst(UNARY_NOT, (value -- res)) {
         147                 :        636 :             int err = PyObject_IsTrue(value);
         148                 :            :             DECREF_INPUTS();
         149         [ -  + ]:        636 :             ERROR_IF(err < 0, error);
         150         [ +  + ]:        636 :             if (err == 0) {
         151                 :        353 :                 res = Py_True;
         152                 :            :             }
         153                 :            :             else {
         154                 :        283 :                 res = Py_False;
         155                 :            :             }
         156                 :        636 :             Py_INCREF(res);
         157                 :            :         }
         158                 :            :
         159                 :            :         inst(UNARY_INVERT, (value -- res)) {
         160                 :      18211 :             res = PyNumber_Invert(value);
         161                 :            :             DECREF_INPUTS();
         162         [ -  + ]:      18211 :             ERROR_IF(res == NULL, error);
         163                 :            :         }
         164                 :            :
         165                 :            :         family(binary_op, INLINE_CACHE_ENTRIES_BINARY_OP) = {
         166                 :            :             BINARY_OP,
         167                 :            :             BINARY_OP_ADD_FLOAT,
         168                 :            :             BINARY_OP_ADD_INT,
         169                 :            :             BINARY_OP_ADD_UNICODE,
         170                 :            :             // BINARY_OP_INPLACE_ADD_UNICODE,  // This is an odd duck.
         171                 :            :             BINARY_OP_MULTIPLY_FLOAT,
         172                 :            :             BINARY_OP_MULTIPLY_INT,
         173                 :            :             BINARY_OP_SUBTRACT_FLOAT,
         174                 :            :             BINARY_OP_SUBTRACT_INT,
         175                 :            :         };
         176                 :            :
         177                 :            :
         178                 :            :         inst(BINARY_OP_MULTIPLY_INT, (unused/1, left, right -- prod)) {
         179                 :            :             assert(cframe.use_tracing == 0);
         180         [ +  + ]:     439353 :             DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
         181         [ +  + ]:     439279 :             DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
         182                 :            :             STAT_INC(BINARY_OP, hit);
         183                 :     439275 :             prod = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right);
         184         [ +  + ]:     439275 :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
         185         [ +  + ]:     439275 :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
         186         [ -  + ]:     439275 :             ERROR_IF(prod == NULL, error);
         187                 :            :         }
         188                 :            :
         189                 :            :         inst(BINARY_OP_MULTIPLY_FLOAT, (unused/1, left, right -- prod)) {
         190                 :            :             assert(cframe.use_tracing == 0);
         191         [ +  + ]:     602046 :             DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
         192         [ -  + ]:     602045 :             DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);
         193                 :            :             STAT_INC(BINARY_OP, hit);
         194                 :     602045 :             double dprod = ((PyFloatObject *)left)->ob_fval *
         195                 :     602045 :                 ((PyFloatObject *)right)->ob_fval;
         196   [ +  +  -  +  :     602045 :             DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dprod, prod);
                 +  +  -  + ]
         197                 :            :         }
         198                 :            :
         199                 :            :         inst(BINARY_OP_SUBTRACT_INT, (unused/1, left, right -- sub)) {
         200                 :            :             assert(cframe.use_tracing == 0);
         201         [ -  + ]:    1662277 :             DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
         202         [ -  + ]:    1662277 :             DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
         203                 :            :             STAT_INC(BINARY_OP, hit);
         204                 :    1662277 :             sub = _PyLong_Subtract((PyLongObject *)left, (PyLongObject *)right);
         205         [ +  + ]:    1662277 :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
         206         [ +  + ]:    1662277 :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
         207         [ -  + ]:    1662277 :             ERROR_IF(sub == NULL, error);
         208                 :            :         }
         209                 :            :
         210                 :            :         inst(BINARY_OP_SUBTRACT_FLOAT, (unused/1, left, right -- sub)) {
         211                 :            :             assert(cframe.use_tracing == 0);
         212         [ -  + ]:     655270 :             DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
         213         [ +  + ]:     655270 :             DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);
         214                 :            :             STAT_INC(BINARY_OP, hit);
         215                 :     654271 :             double dsub = ((PyFloatObject *)left)->ob_fval - ((PyFloatObject *)right)->ob_fval;
         216   [ +  +  +  +  :     654271 :             DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dsub, sub);
                 +  +  -  + ]
         217                 :            :         }
         218                 :            :
         219                 :            :         inst(BINARY_OP_ADD_UNICODE, (unused/1, left, right -- res)) {
         220                 :            :             assert(cframe.use_tracing == 0);
         221         [ -  + ]:      92351 :             DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);
         222         [ -  + ]:      92351 :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
         223                 :            :             STAT_INC(BINARY_OP, hit);
         224                 :      92351 :             res = PyUnicode_Concat(left, right);
         225         [ +  + ]:      92351 :             _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
         226         [ +  + ]:      92351 :             _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
         227         [ -  + ]:      92351 :             ERROR_IF(res == NULL, error);
         228                 :            :         }
         229                 :            :
         230                 :            :         // This is a subtle one. It's a super-instruction for
         231                 :            :         // BINARY_OP_ADD_UNICODE followed by STORE_FAST
         232                 :            :         // where the store goes into the left argument.
         233                 :            :         // So the inputs are the same as for all BINARY_OP
         234                 :            :         // specializations, but there is no output.
         235                 :            :         // At the end we just skip over the STORE_FAST.
         236                 :            :         inst(BINARY_OP_INPLACE_ADD_UNICODE, (left, right --)) {
         237                 :            :             assert(cframe.use_tracing == 0);
         238         [ -  + ]:       2293 :             DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);
         239         [ -  + ]:       2240 :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
         240                 :       2240 :             _Py_CODEUNIT true_next = next_instr[INLINE_CACHE_ENTRIES_BINARY_OP];
         241                 :            :             assert(true_next.op.code == STORE_FAST ||
         242                 :            :                    true_next.op.code == STORE_FAST__LOAD_FAST);
         243                 :       2240 :             PyObject **target_local = &GETLOCAL(true_next.op.arg);
         244         [ +  + ]:       2240 :             DEOPT_IF(*target_local != left, BINARY_OP);
         245                 :            :             STAT_INC(BINARY_OP, hit);
         246                 :            :             /* Handle `left = left + right` or `left += right` for str.
         247                 :            :              *
         248                 :            :              * When possible, extend `left` in place rather than
         249                 :            :              * allocating a new PyUnicodeObject. This attempts to avoid
         250                 :            :              * quadratic behavior when one neglects to use str.join().
         251                 :            :              *
         252                 :            :              * If `left` has only two references remaining (one from
         253                 :            :              * the stack, one in the locals), DECREFing `left` leaves
         254                 :            :              * only the locals reference, so PyUnicode_Append knows
         255                 :            :              * that the string is safe to mutate.
         256                 :            :              */
         257                 :            :             assert(Py_REFCNT(left) >= 2);
         258                 :       2187 :             _Py_DECREF_NO_DEALLOC(left);
         259                 :       2187 :             PyUnicode_Append(target_local, right);
         260         [ +  + ]:       2187 :             _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
         261         [ -  + ]:       2187 :             ERROR_IF(*target_local == NULL, error);
         262                 :            :             // The STORE_FAST is already done.
         263                 :       2187 :             JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP + 1);
         264                 :            :         }
         265                 :            :
         266                 :            :         inst(BINARY_OP_ADD_FLOAT, (unused/1, left, right -- sum)) {
         267                 :            :             assert(cframe.use_tracing == 0);
         268         [ +  + ]:     201021 :             DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
         269         [ -  + ]:     200022 :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
         270                 :            :             STAT_INC(BINARY_OP, hit);
         271                 :     200022 :             double dsum = ((PyFloatObject *)left)->ob_fval +
         272                 :     200022 :                 ((PyFloatObject *)right)->ob_fval;
         273   [ +  +  +  -  :     200022 :             DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dsum, sum);
                 -  +  -  + ]
         274                 :            :         }
         275                 :            :
         276                 :            :         inst(BINARY_OP_ADD_INT, (unused/1, left, right -- sum)) {
         277                 :            :             assert(cframe.use_tracing == 0);
         278         [ -  + ]:    1310070 :             DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
         279         [ +  + ]:    1310070 :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
         280                 :            :             STAT_INC(BINARY_OP, hit);
         281                 :    1310038 :             sum = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right);
         282         [ +  + ]:    1310038 :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
         283         [ +  + ]:    1310038 :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
         284         [ -  + ]:    1310038 :             ERROR_IF(sum == NULL, error);
         285                 :            :         }
         286                 :            :
         287                 :            :         family(binary_subscr, INLINE_CACHE_ENTRIES_BINARY_SUBSCR) = {
         288                 :            :             BINARY_SUBSCR,
         289                 :            :             BINARY_SUBSCR_DICT,
         290                 :            :             BINARY_SUBSCR_GETITEM,
         291                 :            :             BINARY_SUBSCR_LIST_INT,
         292                 :            :             BINARY_SUBSCR_TUPLE_INT,
         293                 :            :         };
         294                 :            :
         295                 :            :         inst(BINARY_SUBSCR, (unused/4, container, sub -- res)) {
         296                 :            :             #if ENABLE_SPECIALIZATION
         297                 :     114248 :             _PyBinarySubscrCache *cache = (_PyBinarySubscrCache *)next_instr;
         298         [ +  + ]:     114248 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
         299                 :            :                 assert(cframe.use_tracing == 0);
         300                 :       1443 :                 next_instr--;
         301                 :       1443 :                 _Py_Specialize_BinarySubscr(container, sub, next_instr);
         302                 :       1443 :                 DISPATCH_SAME_OPARG();
         303                 :            :             }
         304                 :            :             STAT_INC(BINARY_SUBSCR, deferred);
         305                 :     112805 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
         306                 :            :             #endif  /* ENABLE_SPECIALIZATION */
         307                 :     112805 :             res = PyObject_GetItem(container, sub);
         308                 :            :             DECREF_INPUTS();
         309         [ +  + ]:     112805 :             ERROR_IF(res == NULL, error);
         310                 :            :         }
         311                 :            :
         312                 :            :         inst(BINARY_SLICE, (container, start, stop -- res)) {
         313                 :      81347 :             PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
         314                 :            :             // Can't use ERROR_IF() here, because we haven't
         315                 :            :             // DECREF'ed container yet, and we still own slice.
         316         [ -  + ]:      81347 :             if (slice == NULL) {
         317                 :          0 :                 res = NULL;
         318                 :            :             }
         319                 :            :             else {
         320                 :      81347 :                 res = PyObject_GetItem(container, slice);
         321         [ +  - ]:      81347 :                 Py_DECREF(slice);
         322                 :            :             }
         323         [ +  + ]:      81347 :             Py_DECREF(container);
         324         [ -  + ]:      81347 :             ERROR_IF(res == NULL, error);
         325                 :            :         }
         326                 :            :
         327                 :            :         inst(STORE_SLICE, (v, container, start, stop -- )) {
         328                 :         46 :             PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
         329                 :            :             int err;
         330         [ -  + ]:         46 :             if (slice == NULL) {
         331                 :          0 :                 err = 1;
         332                 :            :             }
         333                 :            :             else {
         334                 :         46 :                 err = PyObject_SetItem(container, slice, v);
         335         [ +  - ]:         46 :                 Py_DECREF(slice);
         336                 :            :             }
         337         [ +  + ]:         46 :             Py_DECREF(v);
         338         [ -  + ]:         46 :             Py_DECREF(container);
         339         [ -  + ]:         46 :             ERROR_IF(err, error);
         340                 :            :         }
         341                 :            :
         342                 :            :         inst(BINARY_SUBSCR_LIST_INT, (unused/4, list, sub -- res)) {
         343                 :            :             assert(cframe.use_tracing == 0);
         344         [ -  + ]:     538690 :             DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
         345         [ -  + ]:     538690 :             DEOPT_IF(!PyList_CheckExact(list), BINARY_SUBSCR);
         346                 :            :
         347                 :            :             // Deopt unless 0 <= sub < PyList_Size(list)
         348         [ -  + ]:     538690 :             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), BINARY_SUBSCR);
         349                 :            :             assert(((PyLongObject *)_PyLong_GetZero())->long_value.ob_digit[0] == 0);
         350                 :     538690 :             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
         351         [ +  + ]:     538690 :             DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);
         352                 :            :             STAT_INC(BINARY_SUBSCR, hit);
         353                 :     538155 :             res = PyList_GET_ITEM(list, index);
         354                 :            :             assert(res != NULL);
         355                 :     538155 :             Py_INCREF(res);
         356         [ +  + ]:     538155 :             _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
         357         [ +  + ]:     538155 :             Py_DECREF(list);
         358                 :            :         }
         359                 :            :
         360                 :            :         inst(BINARY_SUBSCR_TUPLE_INT, (unused/4, tuple, sub -- res)) {
         361                 :            :             assert(cframe.use_tracing == 0);
         362         [ -  + ]:      12648 :             DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
         363         [ -  + ]:      12648 :             DEOPT_IF(!PyTuple_CheckExact(tuple), BINARY_SUBSCR);
         364                 :            :
         365                 :            :             // Deopt unless 0 <= sub < PyTuple_Size(list)
         366         [ -  + ]:      12648 :             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), BINARY_SUBSCR);
         367                 :            :             assert(((PyLongObject *)_PyLong_GetZero())->long_value.ob_digit[0] == 0);
         368                 :      12648 :             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
         369         [ -  + ]:      12648 :             DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);
         370                 :            :             STAT_INC(BINARY_SUBSCR, hit);
         371                 :      12648 :             res = PyTuple_GET_ITEM(tuple, index);
         372                 :            :             assert(res != NULL);
         373                 :      12648 :             Py_INCREF(res);
         374         [ -  + ]:      12648 :             _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
         375         [ +  + ]:      12648 :             Py_DECREF(tuple);
         376                 :            :         }
         377                 :            :
         378                 :            :         inst(BINARY_SUBSCR_DICT, (unused/4, dict, sub -- res)) {
         379                 :            :             assert(cframe.use_tracing == 0);
         380         [ -  + ]:      24503 :             DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR);
         381                 :            :             STAT_INC(BINARY_SUBSCR, hit);
         382                 :      24503 :             res = PyDict_GetItemWithError(dict, sub);
         383         [ +  + ]:      24503 :             if (res == NULL) {
         384         [ +  - ]:       1336 :                 if (!_PyErr_Occurred(tstate)) {
         385                 :       1336 :                     _PyErr_SetKeyError(sub);
         386                 :            :                 }
         387                 :            :                 DECREF_INPUTS();
         388                 :       1336 :                 ERROR_IF(true, error);
         389                 :            :             }
         390                 :      23167 :             Py_INCREF(res);  // Do this before DECREF'ing dict, sub
         391                 :            :             DECREF_INPUTS();
         392                 :            :         }
         393                 :            :
         394                 :            :         inst(BINARY_SUBSCR_GETITEM, (unused/1, type_version/2, func_version/1, container, sub -- unused)) {
         395                 :       2025 :             PyTypeObject *tp = Py_TYPE(container);
         396         [ -  + ]:       2025 :             DEOPT_IF(tp->tp_version_tag != type_version, BINARY_SUBSCR);
         397                 :            :             assert(tp->tp_flags & Py_TPFLAGS_HEAPTYPE);
         398                 :       2025 :             PyObject *cached = ((PyHeapTypeObject *)tp)->_spec_cache.getitem;
         399                 :            :             assert(PyFunction_Check(cached));
         400                 :       2025 :             PyFunctionObject *getitem = (PyFunctionObject *)cached;
         401         [ -  + ]:       2025 :             DEOPT_IF(getitem->func_version != func_version, BINARY_SUBSCR);
         402                 :       2025 :             PyCodeObject *code = (PyCodeObject *)getitem->func_code;
         403                 :            :             assert(code->co_argcount == 2);
         404         [ -  + ]:       2025 :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), BINARY_SUBSCR);
         405                 :            :             STAT_INC(BINARY_SUBSCR, hit);
         406                 :       2025 :             Py_INCREF(getitem);
         407                 :       2025 :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, getitem, 2);
         408                 :       2025 :             STACK_SHRINK(2);
         409                 :       2025 :             new_frame->localsplus[0] = container;
         410                 :       2025 :             new_frame->localsplus[1] = sub;
         411                 :       2025 :             JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
         412                 :       2025 :             DISPATCH_INLINED(new_frame);
         413                 :            :         }
         414                 :            :
         415                 :            :         inst(LIST_APPEND, (list, unused[oparg-1], v -- list, unused[oparg-1])) {
         416         [ -  + ]:     411909 :             ERROR_IF(_PyList_AppendTakeRef((PyListObject *)list, v) < 0, error);
         417                 :            :             PREDICT(JUMP_BACKWARD);
         418                 :            :         }
         419                 :            :
         420                 :            :         inst(SET_ADD, (set, unused[oparg-1], v -- set, unused[oparg-1])) {
         421                 :         51 :             int err = PySet_Add(set, v);
         422                 :            :             DECREF_INPUTS();
         423         [ -  + ]:         51 :             ERROR_IF(err, error);
         424                 :            :             PREDICT(JUMP_BACKWARD);
         425                 :            :         }
         426                 :            :
         427                 :            :         family(store_subscr, INLINE_CACHE_ENTRIES_STORE_SUBSCR) = {
         428                 :            :             STORE_SUBSCR,
         429                 :            :             STORE_SUBSCR_DICT,
         430                 :            :             STORE_SUBSCR_LIST_INT,
         431                 :            :         };
         432                 :            :
         433                 :            :         inst(STORE_SUBSCR, (counter/1, v, container, sub -- )) {
         434                 :            :             #if ENABLE_SPECIALIZATION
         435         [ +  + ]:       6909 :             if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {
         436                 :            :                 assert(cframe.use_tracing == 0);
         437                 :        565 :                 next_instr--;
         438                 :        565 :                 _Py_Specialize_StoreSubscr(container, sub, next_instr);
         439                 :        565 :                 DISPATCH_SAME_OPARG();
         440                 :            :             }
         441                 :            :             STAT_INC(STORE_SUBSCR, deferred);
         442                 :       6344 :             _PyStoreSubscrCache *cache = (_PyStoreSubscrCache *)next_instr;
         443                 :       6344 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
         444                 :            :             #else
         445                 :            :             (void)counter;  // Unused.
         446                 :            :             #endif  /* ENABLE_SPECIALIZATION */
         447                 :            :             /* container[sub] = v */
         448                 :       6344 :             int err = PyObject_SetItem(container, sub, v);
         449                 :            :             DECREF_INPUTS();
         450         [ +  + ]:       6344 :             ERROR_IF(err, error);
         451                 :            :         }
         452                 :            :
         453                 :            :         inst(STORE_SUBSCR_LIST_INT, (unused/1, value, list, sub -- )) {
         454                 :            :             assert(cframe.use_tracing == 0);
         455         [ -  + ]:     519769 :             DEOPT_IF(!PyLong_CheckExact(sub), STORE_SUBSCR);
         456         [ -  + ]:     519769 :             DEOPT_IF(!PyList_CheckExact(list), STORE_SUBSCR);
         457                 :            :
         458                 :            :             // Ensure nonnegative, zero-or-one-digit ints.
         459         [ -  + ]:     519769 :             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), STORE_SUBSCR);
         460                 :     519769 :             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
         461                 :            :             // Ensure index < len(list)
         462         [ -  + ]:     519769 :             DEOPT_IF(index >= PyList_GET_SIZE(list), STORE_SUBSCR);
         463                 :            :             STAT_INC(STORE_SUBSCR, hit);
         464                 :            :
         465                 :     519769 :             PyObject *old_value = PyList_GET_ITEM(list, index);
         466                 :     519769 :             PyList_SET_ITEM(list, index, value);
         467                 :            :             assert(old_value != NULL);
         468         [ +  + ]:     519769 :             Py_DECREF(old_value);
         469         [ -  + ]:     519769 :             _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
         470         [ -  + ]:     519769 :             Py_DECREF(list);
         471                 :            :         }
         472                 :            :
         473                 :            :         inst(STORE_SUBSCR_DICT, (unused/1, value, dict, sub -- )) {
         474                 :            :             assert(cframe.use_tracing == 0);
         475         [ -  + ]:     101571 :             DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR);
         476                 :            :             STAT_INC(STORE_SUBSCR, hit);
         477                 :     101571 :             int err = _PyDict_SetItem_Take2((PyDictObject *)dict, sub, value);
         478         [ -  + ]:     101571 :             Py_DECREF(dict);
         479         [ -  + ]:     101571 :             ERROR_IF(err, error);
         480                 :            :         }
         481                 :            :
         482                 :            :         inst(DELETE_SUBSCR, (container, sub --)) {
         483                 :            :             /* del container[sub] */
         484                 :       1235 :             int err = PyObject_DelItem(container, sub);
         485                 :            :             DECREF_INPUTS();
         486         [ +  + ]:       1235 :             ERROR_IF(err, error);
         487                 :            :         }
         488                 :            :
         489                 :            :         inst(CALL_INTRINSIC_1, (value -- res)) {
         490                 :            :             assert(oparg <= MAX_INTRINSIC_1);
         491                 :       3351 :             res = _PyIntrinsics_UnaryFunctions[oparg](tstate, value);
         492                 :            :             DECREF_INPUTS();
         493         [ -  + ]:       3351 :             ERROR_IF(res == NULL, error);
         494                 :            :         }
         495                 :            :
         496                 :            :         inst(CALL_INTRINSIC_2, (value2, value1 -- res)) {
         497                 :            :             assert(oparg <= MAX_INTRINSIC_2);
         498                 :          0 :             res = _PyIntrinsics_BinaryFunctions[oparg](tstate, value2, value1);
         499                 :            :             DECREF_INPUTS();
         500         [ #  # ]:          0 :             ERROR_IF(res == NULL, error);
         501                 :            :         }
         502                 :            :
         503                 :            :         inst(RAISE_VARARGS, (args[oparg] -- )) {
         504                 :        413 :             PyObject *cause = NULL, *exc = NULL;
         505   [ +  +  +  - ]:        413 :             switch (oparg) {
         506                 :         93 :             case 2:
         507                 :         93 :                 cause = args[1];
         508                 :            :                 /* fall through */
         509                 :        411 :             case 1:
         510                 :        411 :                 exc = args[0];
         511                 :            :                 /* fall through */
         512                 :        413 :             case 0:
         513         [ +  + ]:        413 :                 ERROR_IF(do_raise(tstate, exc, cause), exception_unwind);
         514                 :        411 :                 break;
         515                 :          0 :             default:
         516                 :          0 :                 _PyErr_SetString(tstate, PyExc_SystemError,
         517                 :            :                                  "bad RAISE_VARARGS oparg");
         518                 :          0 :                 break;
         519                 :            :             }
         520                 :        411 :             ERROR_IF(true, error);
         521                 :            :         }
         522                 :            :
         523                 :            :         inst(INTERPRETER_EXIT, (retval --)) {
         524                 :            :             assert(frame == &entry_frame);
         525                 :            :             assert(_PyFrame_IsIncomplete(frame));
         526                 :    1673510 :             STACK_SHRINK(1);  // Since we're not going to DISPATCH()
         527                 :            :             assert(EMPTY());
         528                 :            :             /* Restore previous cframe and return. */
         529                 :    1673510 :             tstate->cframe = cframe.previous;
         530                 :    1673510 :             tstate->cframe->use_tracing = cframe.use_tracing;
         531                 :            :             assert(tstate->cframe->current_frame == frame->previous);
         532                 :            :             assert(!_PyErr_Occurred(tstate));
         533                 :    1673510 :             _Py_LeaveRecursiveCallTstate(tstate);
         534                 :    1673510 :             return retval;
         535                 :            :         }
         536                 :            :
         537                 :            :         inst(RETURN_VALUE, (retval --)) {
         538                 :    2531207 :             STACK_SHRINK(1);
         539                 :            :             assert(EMPTY());
         540                 :    2531207 :             _PyFrame_SetStackPointer(frame, stack_pointer);
         541   [ -  +  -  -  :    2531207 :             TRACE_FUNCTION_EXIT();
                       -  - ]
         542         [ -  + ]:    2531207 :             DTRACE_FUNCTION_EXIT();
         543                 :    2531207 :             _Py_LeaveRecursiveCallPy(tstate);
         544                 :            :             assert(frame != &entry_frame);
         545                 :            :             // GH-99729: We need to unlink the frame *before* clearing it:
         546                 :    2531207 :             _PyInterpreterFrame *dying = frame;
         547                 :    2531207 :             frame = cframe.current_frame = dying->previous;
         548                 :    2531207 :             _PyEvalFrameClearAndPop(tstate, dying);
         549                 :    2531207 :             _PyFrame_StackPush(frame, retval);
         550                 :    2531207 :             goto resume_frame;
         551                 :            :         }
         552                 :            :
         553                 :            :         inst(RETURN_CONST, (--)) {
         554                 :    1073392 :             PyObject *retval = GETITEM(frame->f_code->co_consts, oparg);
         555                 :    1073392 :             Py_INCREF(retval);
         556                 :            :             assert(EMPTY());
         557                 :    1073392 :             _PyFrame_SetStackPointer(frame, stack_pointer);
         558   [ -  +  -  -  :    1073392 :             TRACE_FUNCTION_EXIT();
                       -  - ]
         559         [ -  + ]:    1073392 :             DTRACE_FUNCTION_EXIT();
         560                 :    1073392 :             _Py_LeaveRecursiveCallPy(tstate);
         561                 :            :             assert(frame != &entry_frame);
         562                 :            :             // GH-99729: We need to unlink the frame *before* clearing it:
         563                 :    1073392 :             _PyInterpreterFrame *dying = frame;
         564                 :    1073392 :             frame = cframe.current_frame = dying->previous;
         565                 :    1073392 :             _PyEvalFrameClearAndPop(tstate, dying);
         566                 :    1073392 :             _PyFrame_StackPush(frame, retval);
         567                 :    1073392 :             goto resume_frame;
         568                 :            :         }
         569                 :            :
         570                 :            :         inst(GET_AITER, (obj -- iter)) {
         571                 :          0 :             unaryfunc getter = NULL;
         572                 :          0 :             PyTypeObject *type = Py_TYPE(obj);
         573                 :            :
         574         [ #  # ]:          0 :             if (type->tp_as_async != NULL) {
         575                 :          0 :                 getter = type->tp_as_async->am_aiter;
         576                 :            :             }
         577                 :            :
         578         [ #  # ]:          0 :             if (getter == NULL) {
         579                 :          0 :                 _PyErr_Format(tstate, PyExc_TypeError,
         580                 :            :                               "'async for' requires an object with "
         581                 :            :                               "__aiter__ method, got %.100s",
         582                 :            :                               type->tp_name);
         583                 :            :                 DECREF_INPUTS();
         584                 :          0 :                 ERROR_IF(true, error);
         585                 :            :             }
         586                 :            :
         587                 :          0 :             iter = (*getter)(obj);
         588                 :            :             DECREF_INPUTS();
         589         [ #  # ]:          0 :             ERROR_IF(iter == NULL, error);
         590                 :            :
         591         [ #  # ]:          0 :             if (Py_TYPE(iter)->tp_as_async == NULL ||
         592         [ #  # ]:          0 :                     Py_TYPE(iter)->tp_as_async->am_anext == NULL) {
         593                 :            :
         594                 :          0 :                 _PyErr_Format(tstate, PyExc_TypeError,
         595                 :            :                               "'async for' received an object from __aiter__ "
         596                 :            :                               "that does not implement __anext__: %.100s",
         597                 :          0 :                               Py_TYPE(iter)->tp_name);
         598         [ #  # ]:          0 :                 Py_DECREF(iter);
         599                 :          0 :                 ERROR_IF(true, error);
         600                 :            :             }
         601                 :            :         }
         602                 :            :
         603                 :            :         inst(GET_ANEXT, (aiter -- aiter, awaitable)) {
         604                 :          0 :             unaryfunc getter = NULL;
         605                 :          0 :             PyObject *next_iter = NULL;
         606                 :          0 :             PyTypeObject *type = Py_TYPE(aiter);
         607                 :            :
         608         [ #  # ]:          0 :             if (PyAsyncGen_CheckExact(aiter)) {
         609                 :          0 :                 awaitable = type->tp_as_async->am_anext(aiter);
         610         [ #  # ]:          0 :                 if (awaitable == NULL) {
         611                 :          0 :                     goto error;
         612                 :            :                 }
         613                 :            :             } else {
         614         [ #  # ]:          0 :                 if (type->tp_as_async != NULL){
         615                 :          0 :                     getter = type->tp_as_async->am_anext;
         616                 :            :                 }
         617                 :            :
         618         [ #  # ]:          0 :                 if (getter != NULL) {
         619                 :          0 :                     next_iter = (*getter)(aiter);
         620         [ #  # ]:          0 :                     if (next_iter == NULL) {
         621                 :          0 :                         goto error;
         622                 :            :                     }
         623                 :            :                 }
         624                 :            :                 else {
         625                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
         626                 :            :                                   "'async for' requires an iterator with "
         627                 :            :                                   "__anext__ method, got %.100s",
         628                 :            :                                   type->tp_name);
         629                 :          0 :                     goto error;
         630                 :            :                 }
         631                 :            :
         632                 :          0 :                 awaitable = _PyCoro_GetAwaitableIter(next_iter);
         633         [ #  # ]:          0 :                 if (awaitable == NULL) {
         634                 :          0 :                     _PyErr_FormatFromCause(
         635                 :            :                         PyExc_TypeError,
         636                 :            :                         "'async for' received an invalid object "
         637                 :            :                         "from __anext__: %.100s",
         638                 :          0 :                         Py_TYPE(next_iter)->tp_name);
         639                 :            :
         640         [ #  # ]:          0 :                     Py_DECREF(next_iter);
         641                 :          0 :                     goto error;
         642                 :            :                 } else {
         643         [ #  # ]:          0 :                     Py_DECREF(next_iter);
         644                 :            :                 }
         645                 :            :             }
         646                 :            :
         647                 :            :             PREDICT(LOAD_CONST);
         648                 :            :         }
         649                 :            :
         650                 :            :         inst(GET_AWAITABLE, (iterable -- iter)) {
         651                 :          0 :             iter = _PyCoro_GetAwaitableIter(iterable);
         652                 :            :
         653         [ #  # ]:          0 :             if (iter == NULL) {
         654                 :          0 :                 format_awaitable_error(tstate, Py_TYPE(iterable), oparg);
         655                 :            :             }
         656                 :            :
         657                 :            :             DECREF_INPUTS();
         658                 :            :
         659   [ #  #  #  # ]:          0 :             if (iter != NULL && PyCoro_CheckExact(iter)) {
         660                 :          0 :                 PyObject *yf = _PyGen_yf((PyGenObject*)iter);
         661         [ #  # ]:          0 :                 if (yf != NULL) {
         662                 :            :                     /* `iter` is a coroutine object that is being
         663                 :            :                        awaited, `yf` is a pointer to the current awaitable
         664                 :            :                        being awaited on. */
         665         [ #  # ]:          0 :                     Py_DECREF(yf);
         666   [ #  #  #  # ]:          0 :                     Py_CLEAR(iter);
         667                 :          0 :                     _PyErr_SetString(tstate, PyExc_RuntimeError,
         668                 :            :                                      "coroutine is being awaited already");
         669                 :            :                     /* The code below jumps to `error` if `iter` is NULL. */
         670                 :            :                 }
         671                 :            :             }
         672                 :            :
         673         [ #  # ]:          0 :             ERROR_IF(iter == NULL, error);
         674                 :            :
         675                 :            :             PREDICT(LOAD_CONST);
         676                 :            :         }
         677                 :            :
         678                 :            :         family(for_iter, INLINE_CACHE_ENTRIES_FOR_ITER) = {
         679                 :            :             SEND,
         680                 :            :             SEND_GEN,
         681                 :            :         };
         682                 :            :
         683                 :            :         inst(SEND, (unused/1, receiver, v -- receiver, retval)) {
         684                 :            :             #if ENABLE_SPECIALIZATION
         685                 :         36 :             _PySendCache *cache = (_PySendCache *)next_instr;
         686         [ +  + ]:         36 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
         687                 :            :                 assert(cframe.use_tracing == 0);
         688                 :         10 :                 next_instr--;
         689                 :         10 :                 _Py_Specialize_Send(receiver, next_instr);
         690                 :         10 :                 DISPATCH_SAME_OPARG();
         691                 :            :             }
         692                 :            :             STAT_INC(SEND, deferred);
         693                 :         26 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
         694                 :            :             #endif  /* ENABLE_SPECIALIZATION */
         695                 :            :             assert(frame != &entry_frame);
         696   [ +  -  +  - ]:         26 :             if (Py_IsNone(v) && PyIter_Check(receiver)) {
         697                 :         26 :                 retval = Py_TYPE(receiver)->tp_iternext(receiver);
         698                 :            :             }
         699                 :            :             else {
         700                 :          0 :                 retval = PyObject_CallMethodOneArg(receiver, &_Py_ID(send), v);
         701                 :            :             }
         702         [ +  + ]:         26 :             if (retval == NULL) {
         703         [ -  + ]:          7 :                 if (tstate->c_tracefunc != NULL
         704         [ #  # ]:          0 :                         && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
         705                 :          0 :                     call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, frame);
         706         [ +  - ]:          7 :                 if (_PyGen_FetchStopIterationValue(&retval) == 0) {
         707                 :            :                     assert(retval != NULL);
         708                 :          7 :                     JUMPBY(oparg);
         709                 :            :                 }
         710                 :            :                 else {
         711                 :            :                     assert(retval == NULL);
         712                 :          0 :                     goto error;
         713                 :            :                 }
         714                 :            :             }
         715                 :            :             else {
         716                 :            :                 assert(retval != NULL);
         717                 :            :             }
         718         [ -  + ]:         26 :             Py_DECREF(v);
         719                 :            :         }
         720                 :            :
         721                 :            :         inst(SEND_GEN, (unused/1, receiver, v -- receiver)) {
         722                 :            :             assert(cframe.use_tracing == 0);
         723                 :        351 :             PyGenObject *gen = (PyGenObject *)receiver;
         724   [ -  +  -  - ]:        351 :             DEOPT_IF(Py_TYPE(gen) != &PyGen_Type &&
         725                 :            :                      Py_TYPE(gen) != &PyCoro_Type, SEND);
         726         [ -  + ]:        351 :             DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, SEND);
         727                 :            :             STAT_INC(SEND, hit);
         728                 :        351 :             _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
         729                 :        351 :             frame->yield_offset = oparg;
         730                 :        351 :             STACK_SHRINK(1);
         731                 :        351 :             _PyFrame_StackPush(gen_frame, v);
         732                 :        351 :             gen->gi_frame_state = FRAME_EXECUTING;
         733                 :        351 :             gen->gi_exc_state.previous_item = tstate->exc_info;
         734                 :        351 :             tstate->exc_info = &gen->gi_exc_state;
         735                 :        351 :             JUMPBY(INLINE_CACHE_ENTRIES_SEND + oparg);
         736                 :        351 :             DISPATCH_INLINED(gen_frame);
         737                 :            :         }
         738                 :            :
         739                 :            :         inst(YIELD_VALUE, (retval -- unused)) {
         740                 :            :             // NOTE: It's important that YIELD_VALUE never raises an exception!
         741                 :            :             // The compiler treats any exception raised here as a failed close()
         742                 :            :             // or throw() call.
         743                 :            :             assert(frame != &entry_frame);
         744                 :     429374 :             PyGenObject *gen = _PyFrame_GetGenerator(frame);
         745                 :     429374 :             gen->gi_frame_state = FRAME_SUSPENDED;
         746                 :     429374 :             _PyFrame_SetStackPointer(frame, stack_pointer - 1);
         747   [ -  +  -  -  :     429374 :             TRACE_FUNCTION_EXIT();
                       -  - ]
         748         [ -  + ]:     429374 :             DTRACE_FUNCTION_EXIT();
         749                 :     429374 :             tstate->exc_info = gen->gi_exc_state.previous_item;
         750                 :     429374 :             gen->gi_exc_state.previous_item = NULL;
         751                 :     429374 :             _Py_LeaveRecursiveCallPy(tstate);
         752                 :     429374 :             _PyInterpreterFrame *gen_frame = frame;
         753                 :     429374 :             frame = cframe.current_frame = frame->previous;
         754                 :     429374 :             gen_frame->previous = NULL;
         755                 :     429374 :             frame->prev_instr -= frame->yield_offset;
         756                 :     429374 :             _PyFrame_StackPush(frame, retval);
         757                 :     429374 :             goto resume_frame;
         758                 :            :         }
         759                 :            :
         760                 :            :         inst(POP_EXCEPT, (exc_value -- )) {
         761                 :     101972 :             _PyErr_StackItem *exc_info = tstate->exc_info;
         762   [ +  -  +  + ]:     101972 :             Py_XSETREF(exc_info->exc_value, exc_value);
         763                 :            :         }
         764                 :            :
         765                 :            :         inst(RERAISE, (values[oparg], exc -- values[oparg])) {
         766                 :            :             assert(oparg >= 0 && oparg <= 2);
         767         [ +  + ]:       2415 :             if (oparg) {
         768                 :       2324 :                 PyObject *lasti = values[0];
         769         [ +  - ]:       2324 :                 if (PyLong_Check(lasti)) {
         770                 :       2324 :                     frame->prev_instr = _PyCode_CODE(frame->f_code) + PyLong_AsLong(lasti);
         771                 :            :                     assert(!_PyErr_Occurred(tstate));
         772                 :            :                 }
         773                 :            :                 else {
         774                 :            :                     assert(PyLong_Check(lasti));
         775                 :          0 :                     _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int");
         776                 :          0 :                     goto error;
         777                 :            :                 }
         778                 :            :             }
         779                 :            :             assert(exc && PyExceptionInstance_Check(exc));
         780                 :       2415 :             Py_INCREF(exc);
         781                 :       2415 :             _PyErr_SetRaisedException(tstate, exc);
         782                 :       2415 :             goto exception_unwind;
         783                 :            :         }
         784                 :            :
         785                 :            :         inst(END_ASYNC_FOR, (awaitable, exc -- )) {
         786                 :            :             assert(exc && PyExceptionInstance_Check(exc));
         787         [ #  # ]:          0 :             if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
         788                 :            :                 DECREF_INPUTS();
         789                 :            :             }
         790                 :            :             else {
         791                 :          0 :                 Py_INCREF(exc);
         792                 :          0 :                 _PyErr_SetRaisedException(tstate, exc);
         793                 :          0 :                 goto exception_unwind;
         794                 :            :             }
         795                 :            :         }
         796                 :            :
         797                 :            :         inst(CLEANUP_THROW, (sub_iter, last_sent_val, exc_value -- none, value)) {
         798                 :            :             assert(throwflag);
         799                 :            :             assert(exc_value && PyExceptionInstance_Check(exc_value));
         800         [ #  # ]:          0 :             if (PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration)) {
         801                 :          0 :                 value = Py_NewRef(((PyStopIterationObject *)exc_value)->value);
         802                 :            :                 DECREF_INPUTS();
         803                 :          0 :                 none = Py_NewRef(Py_None);
         804                 :            :             }
         805                 :            :             else {
         806                 :          0 :                 _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
         807                 :          0 :                 goto exception_unwind;
         808                 :            :             }
         809                 :            :         }
         810                 :            :
         811                 :            :         inst(LOAD_ASSERTION_ERROR, ( -- value)) {
         812                 :          0 :             value = Py_NewRef(PyExc_AssertionError);
         813                 :            :         }
         814                 :            :
         815                 :            :         inst(LOAD_BUILD_CLASS, ( -- bc)) {
         816         [ +  - ]:       3141 :             if (PyDict_CheckExact(BUILTINS())) {
         817                 :       3141 :                 bc = _PyDict_GetItemWithError(BUILTINS(),
         818                 :            :                                               &_Py_ID(__build_class__));
         819         [ -  + ]:       3141 :                 if (bc == NULL) {
         820         [ #  # ]:          0 :                     if (!_PyErr_Occurred(tstate)) {
         821                 :          0 :                         _PyErr_SetString(tstate, PyExc_NameError,
         822                 :            :                                          "__build_class__ not found");
         823                 :            :                     }
         824                 :          0 :                     ERROR_IF(true, error);
         825                 :            :                 }
         826                 :       3141 :                 Py_INCREF(bc);
         827                 :            :             }
         828                 :            :             else {
         829                 :          0 :                 bc = PyObject_GetItem(BUILTINS(), &_Py_ID(__build_class__));
         830         [ #  # ]:          0 :                 if (bc == NULL) {
         831         [ #  # ]:          0 :                     if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
         832                 :          0 :                         _PyErr_SetString(tstate, PyExc_NameError,
         833                 :            :                                          "__build_class__ not found");
         834                 :          0 :                     ERROR_IF(true, error);
         835                 :            :                 }
         836                 :            :             }
         837                 :            :         }
         838                 :            :
         839                 :            :         inst(STORE_NAME, (v -- )) {
         840                 :      54214 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         841                 :      54214 :             PyObject *ns = LOCALS();
         842                 :            :             int err;
         843         [ -  + ]:      54214 :             if (ns == NULL) {
         844                 :          0 :                 _PyErr_Format(tstate, PyExc_SystemError,
         845                 :            :                               "no locals found when storing %R", name);
         846                 :            :                 DECREF_INPUTS();
         847                 :          0 :                 ERROR_IF(true, error);
         848                 :            :             }
         849         [ +  + ]:      54214 :             if (PyDict_CheckExact(ns))
         850                 :      53897 :                 err = PyDict_SetItem(ns, name, v);
         851                 :            :             else
         852                 :        317 :                 err = PyObject_SetItem(ns, name, v);
         853                 :            :             DECREF_INPUTS();
         854         [ -  + ]:      54214 :             ERROR_IF(err, error);
         855                 :            :         }
         856                 :            :
         857                 :            :         inst(DELETE_NAME, (--)) {
         858                 :        514 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         859                 :        514 :             PyObject *ns = LOCALS();
         860                 :            :             int err;
         861         [ -  + ]:        514 :             if (ns == NULL) {
         862                 :          0 :                 _PyErr_Format(tstate, PyExc_SystemError,
         863                 :            :                               "no locals when deleting %R", name);
         864                 :          0 :                 goto error;
         865                 :            :             }
         866                 :        514 :             err = PyObject_DelItem(ns, name);
         867                 :            :             // Can't use ERROR_IF here.
         868         [ -  + ]:        514 :             if (err != 0) {
         869                 :          0 :                 format_exc_check_arg(tstate, PyExc_NameError,
         870                 :            :                                      NAME_ERROR_MSG,
         871                 :            :                                      name);
         872                 :          0 :                 goto error;
         873                 :            :             }
         874                 :            :         }
         875                 :            :
         876                 :            :         family(unpack_sequence, INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE) = {
         877                 :            :             UNPACK_SEQUENCE,
         878                 :            :             UNPACK_SEQUENCE_TWO_TUPLE,
         879                 :            :             UNPACK_SEQUENCE_TUPLE,
         880                 :            :             UNPACK_SEQUENCE_LIST,
         881                 :            :         };
         882                 :            :
         883                 :            :         inst(UNPACK_SEQUENCE, (unused/1, seq -- unused[oparg])) {
         884                 :            :             #if ENABLE_SPECIALIZATION
         885                 :       1203 :             _PyUnpackSequenceCache *cache = (_PyUnpackSequenceCache *)next_instr;
         886         [ +  + ]:       1203 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
         887                 :            :                 assert(cframe.use_tracing == 0);
         888                 :        532 :                 next_instr--;
         889                 :        532 :                 _Py_Specialize_UnpackSequence(seq, next_instr, oparg);
         890                 :        532 :                 DISPATCH_SAME_OPARG();
         891                 :            :             }
         892                 :            :             STAT_INC(UNPACK_SEQUENCE, deferred);
         893                 :        671 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
         894                 :            :             #endif  /* ENABLE_SPECIALIZATION */
         895                 :        671 :             PyObject **top = stack_pointer + oparg - 1;
         896                 :        671 :             int res = unpack_iterable(tstate, seq, oparg, -1, top);
         897                 :            :             DECREF_INPUTS();
         898         [ -  + ]:        671 :             ERROR_IF(res == 0, error);
         899                 :            :         }
         900                 :            :
         901                 :            :         inst(UNPACK_SEQUENCE_TWO_TUPLE, (unused/1, seq -- values[oparg])) {
         902         [ -  + ]:    1690349 :             DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
         903         [ -  + ]:    1690349 :             DEOPT_IF(PyTuple_GET_SIZE(seq) != 2, UNPACK_SEQUENCE);
         904                 :            :             assert(oparg == 2);
         905                 :            :             STAT_INC(UNPACK_SEQUENCE, hit);
         906                 :    1690349 :             values[0] = Py_NewRef(PyTuple_GET_ITEM(seq, 1));
         907         [ +  + ]:    1690349 :             values[1] = Py_NewRef(PyTuple_GET_ITEM(seq, 0));
         908                 :            :             DECREF_INPUTS();
         909                 :            :         }
         910                 :            :
         911                 :            :         inst(UNPACK_SEQUENCE_TUPLE, (unused/1, seq -- values[oparg])) {
         912         [ -  + ]:      11126 :             DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
         913         [ -  + ]:      11126 :             DEOPT_IF(PyTuple_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
         914                 :            :             STAT_INC(UNPACK_SEQUENCE, hit);
         915                 :      11126 :             PyObject **items = _PyTuple_ITEMS(seq);
         916         [ +  + ]:      50885 :             for (int i = oparg; --i >= 0; ) {
         917                 :      39759 :                 *values++ = Py_NewRef(items[i]);
         918                 :            :             }
         919                 :            :             DECREF_INPUTS();
         920                 :            :         }
         921                 :            :
         922                 :            :         inst(UNPACK_SEQUENCE_LIST, (unused/1, seq -- values[oparg])) {
         923         [ -  + ]:       5127 :             DEOPT_IF(!PyList_CheckExact(seq), UNPACK_SEQUENCE);
         924         [ -  + ]:       5127 :             DEOPT_IF(PyList_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
         925                 :            :             STAT_INC(UNPACK_SEQUENCE, hit);
         926                 :       5127 :             PyObject **items = _PyList_ITEMS(seq);
         927         [ +  + ]:      20050 :             for (int i = oparg; --i >= 0; ) {
         928                 :      14923 :                 *values++ = Py_NewRef(items[i]);
         929                 :            :             }
         930                 :            :             DECREF_INPUTS();
         931                 :            :         }
         932                 :            :
         933                 :            :         inst(UNPACK_EX, (seq -- unused[oparg & 0xFF], unused, unused[oparg >> 8])) {
         934                 :       1994 :             int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
         935                 :       1994 :             PyObject **top = stack_pointer + totalargs - 1;
         936                 :       1994 :             int res = unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8, top);
         937                 :            :             DECREF_INPUTS();
         938         [ -  + ]:       1994 :             ERROR_IF(res == 0, error);
         939                 :            :         }
         940                 :            :
         941                 :            :         family(store_attr, INLINE_CACHE_ENTRIES_STORE_ATTR) = {
         942                 :            :             STORE_ATTR,
         943                 :            :             STORE_ATTR_INSTANCE_VALUE,
         944                 :            :             STORE_ATTR_SLOT,
         945                 :            :             STORE_ATTR_WITH_HINT,
         946                 :            :         };
         947                 :            :
         948                 :            :         inst(STORE_ATTR, (counter/1, unused/3, v, owner --)) {
         949                 :            :             #if ENABLE_SPECIALIZATION
         950         [ +  + ]:     450233 :             if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {
         951                 :            :                 assert(cframe.use_tracing == 0);
         952                 :       9307 :                 PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         953                 :       9307 :                 next_instr--;
         954                 :       9307 :                 _Py_Specialize_StoreAttr(owner, next_instr, name);
         955                 :       9307 :                 DISPATCH_SAME_OPARG();
         956                 :            :             }
         957                 :            :             STAT_INC(STORE_ATTR, deferred);
         958                 :     440926 :             _PyAttrCache *cache = (_PyAttrCache *)next_instr;
         959                 :     440926 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
         960                 :            :             #else
         961                 :            :             (void)counter;  // Unused.
         962                 :            :             #endif  /* ENABLE_SPECIALIZATION */
         963                 :     440926 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         964                 :     440926 :             int err = PyObject_SetAttr(owner, name, v);
         965                 :            :             DECREF_INPUTS();
         966         [ -  + ]:     440926 :             ERROR_IF(err, error);
         967                 :            :         }
         968                 :            :
         969                 :            :         inst(DELETE_ATTR, (owner --)) {
         970                 :     292839 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         971                 :     292839 :             int err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
         972                 :            :             DECREF_INPUTS();
         973         [ -  + ]:     292839 :             ERROR_IF(err, error);
         974                 :            :         }
         975                 :            :
         976                 :            :         inst(STORE_GLOBAL, (v --)) {
         977                 :       1270 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         978                 :       1270 :             int err = PyDict_SetItem(GLOBALS(), name, v);
         979                 :            :             DECREF_INPUTS();
         980         [ -  + ]:       1270 :             ERROR_IF(err, error);
         981                 :            :         }
         982                 :            :
         983                 :            :         inst(DELETE_GLOBAL, (--)) {
         984                 :          0 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         985                 :            :             int err;
         986                 :          0 :             err = PyDict_DelItem(GLOBALS(), name);
         987                 :            :             // Can't use ERROR_IF here.
         988         [ #  # ]:          0 :             if (err != 0) {
         989         [ #  # ]:          0 :                 if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
         990                 :          0 :                     format_exc_check_arg(tstate, PyExc_NameError,
         991                 :            :                                          NAME_ERROR_MSG, name);
         992                 :            :                 }
         993                 :          0 :                 goto error;
         994                 :            :             }
         995                 :            :         }
         996                 :            :
         997                 :            :         inst(LOAD_NAME, ( -- v)) {
         998                 :      35562 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
         999                 :      35562 :             PyObject *locals = LOCALS();
        1000         [ -  + ]:      35562 :             if (locals == NULL) {
        1001                 :          0 :                 _PyErr_Format(tstate, PyExc_SystemError,
        1002                 :            :                               "no locals when loading %R", name);
        1003                 :          0 :                 goto error;
        1004                 :            :             }
        1005         [ +  + ]:      35562 :             if (PyDict_CheckExact(locals)) {
        1006                 :      35456 :                 v = PyDict_GetItemWithError(locals, name);
        1007         [ +  + ]:      35456 :                 if (v != NULL) {
        1008                 :      23685 :                     Py_INCREF(v);
        1009                 :            :                 }
        1010         [ -  + ]:      11771 :                 else if (_PyErr_Occurred(tstate)) {
        1011                 :          0 :                     goto error;
        1012                 :            :                 }
        1013                 :            :             }
        1014                 :            :             else {
        1015                 :        106 :                 v = PyObject_GetItem(locals, name);
        1016         [ +  + ]:        106 :                 if (v == NULL) {
        1017         [ -  + ]:         90 :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
        1018                 :          0 :                         goto error;
        1019                 :         90 :                     _PyErr_Clear(tstate);
        1020                 :            :                 }
        1021                 :            :             }
        1022         [ +  + ]:      35562 :             if (v == NULL) {
        1023                 :      11861 :                 v = PyDict_GetItemWithError(GLOBALS(), name);
        1024         [ +  + ]:      11861 :                 if (v != NULL) {
        1025                 :       5523 :                     Py_INCREF(v);
        1026                 :            :                 }
        1027         [ -  + ]:       6338 :                 else if (_PyErr_Occurred(tstate)) {
        1028                 :          0 :                     goto error;
        1029                 :            :                 }
        1030                 :            :                 else {
        1031         [ +  - ]:       6338 :                     if (PyDict_CheckExact(BUILTINS())) {
        1032                 :       6338 :                         v = PyDict_GetItemWithError(BUILTINS(), name);
        1033         [ +  + ]:       6338 :                         if (v == NULL) {
        1034         [ +  - ]:          1 :                             if (!_PyErr_Occurred(tstate)) {
        1035                 :          1 :                                 format_exc_check_arg(
        1036                 :            :                                         tstate, PyExc_NameError,
        1037                 :            :                                         NAME_ERROR_MSG, name);
        1038                 :            :                             }
        1039                 :          1 :                             goto error;
        1040                 :            :                         }
        1041                 :       6337 :                         Py_INCREF(v);
        1042                 :            :                     }
        1043                 :            :                     else {
        1044                 :          0 :                         v = PyObject_GetItem(BUILTINS(), name);
        1045         [ #  # ]:          0 :                         if (v == NULL) {
        1046         [ #  # ]:          0 :                             if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
        1047                 :          0 :                                 format_exc_check_arg(
        1048                 :            :                                             tstate, PyExc_NameError,
        1049                 :            :                                             NAME_ERROR_MSG, name);
        1050                 :            :                             }
        1051                 :          0 :                             goto error;
        1052                 :            :                         }
        1053                 :            :                     }
        1054                 :            :                 }
        1055                 :            :             }
        1056                 :            :         }
        1057                 :            :
        1058                 :            :         family(load_global, INLINE_CACHE_ENTRIES_LOAD_GLOBAL) = {
        1059                 :            :             LOAD_GLOBAL,
        1060                 :            :             LOAD_GLOBAL_MODULE,
        1061                 :            :             LOAD_GLOBAL_BUILTIN,
        1062                 :            :         };
        1063                 :            :
        1064                 :            :         inst(LOAD_GLOBAL, (unused/1, unused/1, unused/1, unused/1 -- null if (oparg & 1), v)) {
        1065                 :            :             #if ENABLE_SPECIALIZATION
        1066                 :      74883 :             _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
        1067         [ +  + ]:      74883 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
        1068                 :            :                 assert(cframe.use_tracing == 0);
        1069                 :      11080 :                 PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
        1070                 :      11080 :                 next_instr--;
        1071                 :      11080 :                 _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
        1072                 :      11080 :                 DISPATCH_SAME_OPARG();
        1073                 :            :             }
        1074                 :            :             STAT_INC(LOAD_GLOBAL, deferred);
        1075                 :      63803 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
        1076                 :            :             #endif  /* ENABLE_SPECIALIZATION */
        1077                 :      63803 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
        1078         [ +  - ]:      63803 :             if (PyDict_CheckExact(GLOBALS())
        1079         [ +  - ]:      63803 :                 && PyDict_CheckExact(BUILTINS()))
        1080                 :            :             {
        1081                 :      63803 :                 v = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
        1082                 :      63803 :                                        (PyDictObject *)BUILTINS(),
        1083                 :            :                                        name);
        1084         [ -  + ]:      63803 :                 if (v == NULL) {
        1085         [ #  # ]:          0 :                     if (!_PyErr_Occurred(tstate)) {
        1086                 :            :                         /* _PyDict_LoadGlobal() returns NULL without raising
        1087                 :            :                          * an exception if the key doesn't exist */
        1088                 :          0 :                         format_exc_check_arg(tstate, PyExc_NameError,
        1089                 :            :                                              NAME_ERROR_MSG, name);
        1090                 :            :                     }
        1091                 :          0 :                     ERROR_IF(true, error);
        1092                 :            :                 }
        1093                 :      63803 :                 Py_INCREF(v);
        1094                 :            :             }
        1095                 :            :             else {
        1096                 :            :                 /* Slow-path if globals or builtins is not a dict */
        1097                 :            :
        1098                 :            :                 /* namespace 1: globals */
        1099                 :          0 :                 v = PyObject_GetItem(GLOBALS(), name);
        1100         [ #  # ]:          0 :                 if (v == NULL) {
        1101         [ #  # ]:          0 :                     ERROR_IF(!_PyErr_ExceptionMatches(tstate, PyExc_KeyError), error);
        1102                 :          0 :                     _PyErr_Clear(tstate);
        1103                 :            :
        1104                 :            :                     /* namespace 2: builtins */
        1105                 :          0 :                     v = PyObject_GetItem(BUILTINS(), name);
        1106         [ #  # ]:          0 :                     if (v == NULL) {
        1107         [ #  # ]:          0 :                         if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
        1108                 :          0 :                             format_exc_check_arg(
        1109                 :            :                                         tstate, PyExc_NameError,
        1110                 :            :                                         NAME_ERROR_MSG, name);
        1111                 :            :                         }
        1112                 :          0 :                         ERROR_IF(true, error);
        1113                 :            :                     }
        1114                 :            :                 }
        1115                 :            :             }
        1116         [ +  + ]:      63803 :             null = NULL;
        1117                 :            :         }
        1118                 :            :
        1119                 :            :         inst(LOAD_GLOBAL_MODULE, (unused/1, index/1, version/1, unused/1 -- null if (oparg & 1), res)) {
        1120                 :            :             assert(cframe.use_tracing == 0);
        1121         [ -  + ]:    4127977 :             DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
        1122                 :    4127977 :             PyDictObject *dict = (PyDictObject *)GLOBALS();
        1123         [ +  + ]:    4127977 :             DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL);
        1124                 :            :             assert(DK_IS_UNICODE(dict->ma_keys));
        1125                 :    4109990 :             PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dict->ma_keys);
        1126                 :    4109990 :             res = entries[index].me_value;
        1127         [ -  + ]:    4109990 :             DEOPT_IF(res == NULL, LOAD_GLOBAL);
        1128                 :    4109990 :             Py_INCREF(res);
        1129                 :            :             STAT_INC(LOAD_GLOBAL, hit);
        1130         [ +  + ]:    4109990 :             null = NULL;
        1131                 :            :         }
        1132                 :            :
        1133                 :            :         inst(LOAD_GLOBAL_BUILTIN, (unused/1, index/1, mod_version/1, bltn_version/1 -- null if (oparg & 1), res)) {
        1134                 :            :             assert(cframe.use_tracing == 0);
        1135         [ -  + ]:    3589529 :             DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
        1136         [ -  + ]:    3589529 :             DEOPT_IF(!PyDict_CheckExact(BUILTINS()), LOAD_GLOBAL);
        1137                 :    3589529 :             PyDictObject *mdict = (PyDictObject *)GLOBALS();
        1138                 :    3589529 :             PyDictObject *bdict = (PyDictObject *)BUILTINS();
        1139         [ +  + ]:    3589529 :             DEOPT_IF(mdict->ma_keys->dk_version != mod_version, LOAD_GLOBAL);
        1140         [ +  + ]:    3573477 :             DEOPT_IF(bdict->ma_keys->dk_version != bltn_version, LOAD_GLOBAL);
        1141                 :            :             assert(DK_IS_UNICODE(bdict->ma_keys));
        1142                 :    3561513 :             PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(bdict->ma_keys);
        1143                 :    3561513 :             res = entries[index].me_value;
        1144         [ -  + ]:    3561513 :             DEOPT_IF(res == NULL, LOAD_GLOBAL);
        1145                 :    3561513 :             Py_INCREF(res);
        1146                 :            :             STAT_INC(LOAD_GLOBAL, hit);
        1147         [ +  + ]:    3561513 :             null = NULL;
        1148                 :            :         }
        1149                 :            :
        1150                 :            :         inst(DELETE_FAST, (--)) {
        1151                 :         85 :             PyObject *v = GETLOCAL(oparg);
        1152         [ -  + ]:         85 :             ERROR_IF(v == NULL, unbound_local_error);
        1153   [ +  -  -  + ]:         85 :             SETLOCAL(oparg, NULL);
        1154                 :            :         }
        1155                 :            :
        1156                 :            :         inst(MAKE_CELL, (--)) {
        1157                 :            :             // "initial" is probably NULL but not if it's an arg (or set
        1158                 :            :             // via PyFrame_LocalsToFast() before MAKE_CELL has run).
        1159                 :      43879 :             PyObject *initial = GETLOCAL(oparg);
        1160                 :      43879 :             PyObject *cell = PyCell_New(initial);
        1161         [ -  + ]:      43879 :             if (cell == NULL) {
        1162                 :          0 :                 goto resume_with_error;
        1163                 :            :             }
        1164   [ +  +  -  + ]:      43879 :             SETLOCAL(oparg, cell);
        1165                 :            :         }
        1166                 :            :
        1167                 :            :         inst(DELETE_DEREF, (--)) {
        1168                 :          0 :             PyObject *cell = GETLOCAL(oparg);
        1169                 :          0 :             PyObject *oldobj = PyCell_GET(cell);
        1170                 :            :             // Can't use ERROR_IF here.
        1171                 :            :             // Fortunately we don't need its superpower.
        1172         [ #  # ]:          0 :             if (oldobj == NULL) {
        1173                 :          0 :                 format_exc_unbound(tstate, frame->f_code, oparg);
        1174                 :          0 :                 goto error;
        1175                 :            :             }
        1176                 :          0 :             PyCell_SET(cell, NULL);
        1177         [ #  # ]:          0 :             Py_DECREF(oldobj);
        1178                 :            :         }
        1179                 :            :
        1180                 :            :         inst(LOAD_CLASSDEREF, ( -- value)) {
        1181                 :         14 :             PyObject *name, *locals = LOCALS();
        1182                 :            :             assert(locals);
        1183                 :            :             assert(oparg >= 0 && oparg < frame->f_code->co_nlocalsplus);
        1184                 :         14 :             name = PyTuple_GET_ITEM(frame->f_code->co_localsplusnames, oparg);
        1185         [ +  - ]:         14 :             if (PyDict_CheckExact(locals)) {
        1186                 :         14 :                 value = PyDict_GetItemWithError(locals, name);
        1187         [ -  + ]:         14 :                 if (value != NULL) {
        1188                 :          0 :                     Py_INCREF(value);
        1189                 :            :                 }
        1190         [ -  + ]:         14 :                 else if (_PyErr_Occurred(tstate)) {
        1191                 :          0 :                     goto error;
        1192                 :            :                 }
        1193                 :            :             }
        1194                 :            :             else {
        1195                 :          0 :                 value = PyObject_GetItem(locals, name);
        1196         [ #  # ]:          0 :                 if (value == NULL) {
        1197         [ #  # ]:          0 :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
        1198                 :          0 :                         goto error;
        1199                 :            :                     }
        1200                 :          0 :                     _PyErr_Clear(tstate);
        1201                 :            :                 }
        1202                 :            :             }
        1203         [ +  - ]:         14 :             if (!value) {
        1204                 :         14 :                 PyObject *cell = GETLOCAL(oparg);
        1205                 :         14 :                 value = PyCell_GET(cell);
        1206         [ -  + ]:         14 :                 if (value == NULL) {
        1207                 :          0 :                     format_exc_unbound(tstate, frame->f_code, oparg);
        1208                 :          0 :                     goto error;
        1209                 :            :                 }
        1210                 :         14 :                 Py_INCREF(value);
        1211                 :            :             }
        1212                 :            :         }
        1213                 :            :
        1214                 :            :         inst(LOAD_DEREF, ( -- value)) {
        1215                 :    1415494 :             PyObject *cell = GETLOCAL(oparg);
        1216                 :    1415494 :             value = PyCell_GET(cell);
        1217         [ -  + ]:    1415494 :             if (value == NULL) {
        1218                 :          0 :                 format_exc_unbound(tstate, frame->f_code, oparg);
        1219                 :          0 :                 ERROR_IF(true, error);
        1220                 :            :             }
        1221                 :    1415494 :             Py_INCREF(value);
        1222                 :            :         }
        1223                 :            :
        1224                 :            :         inst(STORE_DEREF, (v --)) {
        1225                 :      19694 :             PyObject *cell = GETLOCAL(oparg);
        1226                 :      19694 :             PyObject *oldobj = PyCell_GET(cell);
        1227                 :      19694 :             PyCell_SET(cell, v);
        1228   [ +  +  +  + ]:      19694 :             Py_XDECREF(oldobj);
        1229                 :            :         }
        1230                 :            :
        1231                 :            :         inst(COPY_FREE_VARS, (--)) {
        1232                 :            :             /* Copy closure variables to free variables */
        1233                 :     736039 :             PyCodeObject *co = frame->f_code;
        1234                 :            :             assert(PyFunction_Check(frame->f_funcobj));
        1235                 :     736039 :             PyObject *closure = ((PyFunctionObject *)frame->f_funcobj)->func_closure;
        1236                 :            :             assert(oparg == co->co_nfreevars);
        1237                 :     736039 :             int offset = co->co_nlocalsplus - oparg;
        1238         [ +  + ]:    2753237 :             for (int i = 0; i < oparg; ++i) {
        1239                 :    2017198 :                 PyObject *o = PyTuple_GET_ITEM(closure, i);
        1240                 :    2017198 :                 frame->localsplus[offset + i] = Py_NewRef(o);
        1241                 :            :             }
        1242                 :            :         }
        1243                 :            :
        1244                 :            :         inst(BUILD_STRING, (pieces[oparg] -- str)) {
        1245                 :     342034 :             str = _PyUnicode_JoinArray(&_Py_STR(empty), pieces, oparg);
        1246                 :            :             DECREF_INPUTS();
        1247         [ -  + ]:     342034 :             ERROR_IF(str == NULL, error);
        1248                 :            :         }
        1249                 :            :
        1250                 :            :         inst(BUILD_TUPLE, (values[oparg] -- tup)) {
        1251                 :     278852 :             tup = _PyTuple_FromArraySteal(values, oparg);
        1252         [ -  + ]:     278852 :             ERROR_IF(tup == NULL, error);
        1253                 :            :         }
        1254                 :            :
        1255                 :            :         inst(BUILD_LIST, (values[oparg] -- list)) {
        1256                 :     165891 :             list = _PyList_FromArraySteal(values, oparg);
        1257         [ -  + ]:     165891 :             ERROR_IF(list == NULL, error);
        1258                 :            :         }
        1259                 :            :
        1260                 :            :         inst(LIST_EXTEND, (list, unused[oparg-1], iterable -- list, unused[oparg-1])) {
        1261                 :       2739 :             PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
        1262         [ -  + ]:       2739 :             if (none_val == NULL) {
        1263         [ #  # ]:          0 :                 if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
        1264   [ #  #  #  # ]:          0 :                    (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
        1265                 :            :                 {
        1266                 :          0 :                     _PyErr_Clear(tstate);
        1267                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
        1268                 :            :                           "Value after * must be an iterable, not %.200s",
        1269                 :          0 :                           Py_TYPE(iterable)->tp_name);
        1270                 :            :                 }
        1271                 :            :                 DECREF_INPUTS();
        1272                 :          0 :                 ERROR_IF(true, error);
        1273                 :            :             }
        1274         [ -  + ]:       2739 :             Py_DECREF(none_val);
        1275                 :            :             DECREF_INPUTS();
        1276                 :            :         }
        1277                 :            :
        1278                 :            :         inst(SET_UPDATE, (set, unused[oparg-1], iterable -- set, unused[oparg-1])) {
        1279                 :         10 :             int err = _PySet_Update(set, iterable);
        1280                 :            :             DECREF_INPUTS();
        1281         [ -  + ]:         10 :             ERROR_IF(err < 0, error);
        1282                 :            :         }
        1283                 :            :
        1284                 :            :         inst(BUILD_SET, (values[oparg] -- set)) {
        1285                 :        374 :             set = PySet_New(NULL);
        1286         [ -  + ]:        374 :             if (set == NULL)
        1287                 :          0 :                 goto error;
        1288                 :        374 :             int err = 0;
        1289         [ +  + ]:       1256 :             for (int i = 0; i < oparg; i++) {
        1290                 :        882 :                 PyObject *item = values[i];
        1291         [ +  - ]:        882 :                 if (err == 0)
        1292                 :        882 :                     err = PySet_Add(set, item);
        1293         [ -  + ]:        882 :                 Py_DECREF(item);
        1294                 :            :             }
        1295         [ -  + ]:        374 :             if (err != 0) {
        1296         [ #  # ]:          0 :                 Py_DECREF(set);
        1297                 :          0 :                 ERROR_IF(true, error);
        1298                 :            :             }
        1299                 :            :         }
        1300                 :            :
        1301                 :            :         inst(BUILD_MAP, (values[oparg*2] -- map)) {
        1302                 :     120365 :             map = _PyDict_FromItems(
        1303                 :            :                     values, 2,
        1304                 :     120365 :                     values+1, 2,
        1305                 :            :                     oparg);
        1306         [ -  + ]:     120365 :             if (map == NULL)
        1307                 :          0 :                 goto error;
        1308                 :            :
        1309                 :            :             DECREF_INPUTS();
        1310         [ -  + ]:     120365 :             ERROR_IF(map == NULL, error);
        1311                 :            :         }
        1312                 :            :
        1313                 :            :         inst(SETUP_ANNOTATIONS, (--)) {
        1314                 :            :             int err;
        1315                 :            :             PyObject *ann_dict;
        1316         [ -  + ]:          1 :             if (LOCALS() == NULL) {
        1317                 :          0 :                 _PyErr_Format(tstate, PyExc_SystemError,
        1318                 :            :                               "no locals found when setting up annotations");
        1319                 :          0 :                 ERROR_IF(true, error);
        1320                 :            :             }
        1321                 :            :             /* check if __annotations__ in locals()... */
        1322         [ +  - ]:          1 :             if (PyDict_CheckExact(LOCALS())) {
        1323                 :          1 :                 ann_dict = _PyDict_GetItemWithError(LOCALS(),
        1324                 :            :                                                     &_Py_ID(__annotations__));
        1325         [ +  - ]:          1 :                 if (ann_dict == NULL) {
        1326         [ -  + ]:          1 :                     ERROR_IF(_PyErr_Occurred(tstate), error);
        1327                 :            :                     /* ...if not, create a new one */
        1328                 :          1 :                     ann_dict = PyDict_New();
        1329         [ -  + ]:          1 :                     ERROR_IF(ann_dict == NULL, error);
        1330                 :          1 :                     err = PyDict_SetItem(LOCALS(), &_Py_ID(__annotations__),
        1331                 :            :                                          ann_dict);
        1332         [ -  + ]:          1 :                     Py_DECREF(ann_dict);
        1333         [ -  + ]:          1 :                     ERROR_IF(err, error);
        1334                 :            :                 }
        1335                 :            :             }
        1336                 :            :             else {
        1337                 :            :                 /* do the same if locals() is not a dict */
        1338                 :          0 :                 ann_dict = PyObject_GetItem(LOCALS(), &_Py_ID(__annotations__));
        1339         [ #  # ]:          0 :                 if (ann_dict == NULL) {
        1340         [ #  # ]:          0 :                     ERROR_IF(!_PyErr_ExceptionMatches(tstate, PyExc_KeyError), error);
        1341                 :          0 :                     _PyErr_Clear(tstate);
        1342                 :          0 :                     ann_dict = PyDict_New();
        1343         [ #  # ]:          0 :                     ERROR_IF(ann_dict == NULL, error);
        1344                 :          0 :                     err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
        1345                 :            :                                            ann_dict);
        1346         [ #  # ]:          0 :                     Py_DECREF(ann_dict);
        1347         [ #  # ]:          0 :                     ERROR_IF(err, error);
        1348                 :            :                 }
        1349                 :            :                 else {
        1350         [ #  # ]:          0 :                     Py_DECREF(ann_dict);
        1351                 :            :                 }
        1352                 :            :             }
        1353                 :            :         }
        1354                 :            :
        1355                 :            :         inst(BUILD_CONST_KEY_MAP, (values[oparg], keys -- map)) {
        1356         [ +  - ]:       1911 :             if (!PyTuple_CheckExact(keys) ||
        1357         [ -  + ]:       1911 :                 PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) {
        1358                 :          0 :                 _PyErr_SetString(tstate, PyExc_SystemError,
        1359                 :            :                                  "bad BUILD_CONST_KEY_MAP keys argument");
        1360                 :          0 :                 goto error;  // Pop the keys and values.
        1361                 :            :             }
        1362                 :       1911 :             map = _PyDict_FromItems(
        1363                 :       1911 :                     &PyTuple_GET_ITEM(keys, 0), 1,
        1364                 :            :                     values, 1, oparg);
        1365                 :            :             DECREF_INPUTS();
        1366         [ -  + ]:       1911 :             ERROR_IF(map == NULL, error);
        1367                 :            :         }
        1368                 :            :
        1369                 :            :         inst(DICT_UPDATE, (update --)) {
        1370                 :        750 :             PyObject *dict = PEEK(oparg + 1);  // update is still on the stack
        1371         [ -  + ]:        750 :             if (PyDict_Update(dict, update) < 0) {
        1372         [ #  # ]:          0 :                 if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
        1373                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
        1374                 :            :                                     "'%.200s' object is not a mapping",
        1375                 :          0 :                                     Py_TYPE(update)->tp_name);
        1376                 :            :                 }
        1377                 :            :                 DECREF_INPUTS();
        1378                 :          0 :                 ERROR_IF(true, error);
        1379                 :            :             }
        1380                 :            :             DECREF_INPUTS();
        1381                 :            :         }
        1382                 :            :
        1383                 :            :         inst(DICT_MERGE, (update --)) {
        1384                 :     102304 :             PyObject *dict = PEEK(oparg + 1);  // update is still on the stack
        1385                 :            :
        1386         [ -  + ]:     102304 :             if (_PyDict_MergeEx(dict, update, 2) < 0) {
        1387                 :          0 :                 format_kwargs_error(tstate, PEEK(3 + oparg), update);
        1388                 :            :                 DECREF_INPUTS();
        1389                 :          0 :                 ERROR_IF(true, error);
        1390                 :            :             }
        1391                 :            :             DECREF_INPUTS();
        1392                 :            :             PREDICT(CALL_FUNCTION_EX);
        1393                 :            :         }
        1394                 :            :
        1395                 :            :         inst(MAP_ADD, (key, value --)) {
        1396                 :      13896 :             PyObject *dict = PEEK(oparg + 2);  // key, value are still on the stack
        1397                 :            :             assert(PyDict_CheckExact(dict));
        1398                 :            :             /* dict[key] = value */
        1399                 :            :             // Do not DECREF INPUTS because the function steals the references
        1400         [ -  + ]:      13896 :             ERROR_IF(_PyDict_SetItem_Take2((PyDictObject *)dict, key, value) != 0, error);
        1401                 :            :             PREDICT(JUMP_BACKWARD);
        1402                 :            :         }
        1403                 :            :
        1404                 :            :         family(load_attr, INLINE_CACHE_ENTRIES_LOAD_ATTR) = {
        1405                 :            :             LOAD_ATTR,
        1406                 :            :             LOAD_ATTR_INSTANCE_VALUE,
        1407                 :            :             LOAD_ATTR_MODULE,
        1408                 :            :             LOAD_ATTR_WITH_HINT,
        1409                 :            :             LOAD_ATTR_SLOT,
        1410                 :            :             LOAD_ATTR_CLASS,
        1411                 :            :             LOAD_ATTR_PROPERTY,
        1412                 :            :             LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN,
        1413                 :            :             LOAD_ATTR_METHOD_WITH_VALUES,
        1414                 :            :             LOAD_ATTR_METHOD_NO_DICT,
        1415                 :            :             LOAD_ATTR_METHOD_LAZY_DICT,
        1416                 :            :         };
        1417                 :            :
        1418                 :            :         inst(LOAD_ATTR, (unused/9, owner -- res2 if (oparg & 1), res)) {
        1419                 :            :             #if ENABLE_SPECIALIZATION
        1420                 :    1891903 :             _PyAttrCache *cache = (_PyAttrCache *)next_instr;
        1421         [ +  + ]:    1891903 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
        1422                 :            :                 assert(cframe.use_tracing == 0);
        1423                 :      17862 :                 PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
        1424                 :      17862 :                 next_instr--;
        1425                 :      17862 :                 _Py_Specialize_LoadAttr(owner, next_instr, name);
        1426                 :      17862 :                 DISPATCH_SAME_OPARG();
        1427                 :            :             }
        1428                 :            :             STAT_INC(LOAD_ATTR, deferred);
        1429                 :    1874041 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
        1430                 :            :             #endif  /* ENABLE_SPECIALIZATION */
        1431                 :    1874041 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
        1432         [ +  + ]:    1874041 :             if (oparg & 1) {
        1433                 :            :                 /* Designed to work in tandem with CALL, pushes two values. */
        1434                 :     470512 :                 PyObject* meth = NULL;
        1435         [ +  + ]:     470512 :                 if (_PyObject_GetMethod(owner, name, &meth)) {
        1436                 :            :                     /* We can bypass temporary bound method object.
        1437                 :            :                        meth is unbound method and obj is self.
        1438                 :            :
        1439                 :            :                        meth | self | arg1 | ... | argN
        1440                 :            :                      */
        1441                 :            :                     assert(meth != NULL);  // No errors on this branch
        1442                 :     213574 :                     res2 = meth;
        1443                 :     213574 :                     res = owner;  // Transfer ownership
        1444                 :            :                 }
        1445                 :            :                 else {
        1446                 :            :                     /* meth is not an unbound method (but a regular attr, or
        1447                 :            :                        something was returned by a descriptor protocol).  Set
        1448                 :            :                        the second element of the stack to NULL, to signal
        1449                 :            :                        CALL that it's not a method call.
        1450                 :            :
        1451                 :            :                        NULL | meth | arg1 | ... | argN
        1452                 :            :                     */
        1453                 :            :                     DECREF_INPUTS();
        1454         [ +  + ]:     256938 :                     ERROR_IF(meth == NULL, error);
        1455                 :     256889 :                     res2 = NULL;
        1456                 :     256889 :                     res = meth;
        1457                 :            :                 }
        1458                 :            :             }
        1459                 :            :             else {
        1460                 :            :                 /* Classic, pushes one value. */
        1461                 :    1403529 :                 res = PyObject_GetAttr(owner, name);
        1462                 :            :                 DECREF_INPUTS();
        1463         [ +  + ]:    1403529 :                 ERROR_IF(res == NULL, error);
        1464                 :            :             }
        1465                 :            :         }
        1466                 :            :
        1467                 :            :         inst(LOAD_ATTR_INSTANCE_VALUE, (unused/1, type_version/2, index/1, unused/5, owner -- res2 if (oparg & 1), res)) {
        1468                 :            :             assert(cframe.use_tracing == 0);
        1469                 :    1481398 :             PyTypeObject *tp = Py_TYPE(owner);
        1470                 :            :             assert(type_version != 0);
        1471         [ +  + ]:    1481398 :             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
        1472                 :            :             assert(tp->tp_dictoffset < 0);
        1473                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
        1474                 :    1480650 :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
        1475         [ +  + ]:    1480650 :             DEOPT_IF(!_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
        1476                 :    1480649 :             res = _PyDictOrValues_GetValues(dorv)->values[index];
        1477         [ -  + ]:    1480649 :             DEOPT_IF(res == NULL, LOAD_ATTR);
        1478                 :            :             STAT_INC(LOAD_ATTR, hit);
        1479                 :    1480649 :             Py_INCREF(res);
        1480         [ -  + ]:    1480649 :             res2 = NULL;
        1481                 :            :             DECREF_INPUTS();
        1482                 :            :         }
        1483                 :            :
        1484                 :            :         inst(LOAD_ATTR_MODULE, (unused/1, type_version/2, index/1, unused/5, owner -- res2 if (oparg & 1), res)) {
        1485                 :            :             assert(cframe.use_tracing == 0);
        1486         [ -  + ]:    1473626 :             DEOPT_IF(!PyModule_CheckExact(owner), LOAD_ATTR);
        1487                 :    1473626 :             PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner)->md_dict;
        1488                 :            :             assert(dict != NULL);
        1489         [ +  + ]:    1473626 :             DEOPT_IF(dict->ma_keys->dk_version != type_version, LOAD_ATTR);
        1490                 :            :             assert(dict->ma_keys->dk_kind == DICT_KEYS_UNICODE);
        1491                 :            :             assert(index < dict->ma_keys->dk_nentries);
        1492                 :    1462832 :             PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + index;
        1493                 :    1462832 :             res = ep->me_value;
        1494         [ -  + ]:    1462832 :             DEOPT_IF(res == NULL, LOAD_ATTR);
        1495                 :            :             STAT_INC(LOAD_ATTR, hit);
        1496                 :    1462832 :             Py_INCREF(res);
        1497         [ -  + ]:    1462832 :             res2 = NULL;
        1498                 :            :             DECREF_INPUTS();
        1499                 :            :         }
        1500                 :            :
        1501                 :            :         inst(LOAD_ATTR_WITH_HINT, (unused/1, type_version/2, index/1, unused/5, owner -- res2 if (oparg & 1), res)) {
        1502                 :            :             assert(cframe.use_tracing == 0);
        1503                 :     227690 :             PyTypeObject *tp = Py_TYPE(owner);
        1504                 :            :             assert(type_version != 0);
        1505         [ +  + ]:     227690 :             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
        1506                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
        1507                 :     227598 :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
        1508         [ +  + ]:     227598 :             DEOPT_IF(_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
        1509                 :     227562 :             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
        1510         [ -  + ]:     227562 :             DEOPT_IF(dict == NULL, LOAD_ATTR);
        1511                 :            :             assert(PyDict_CheckExact((PyObject *)dict));
        1512                 :     227562 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
        1513                 :     227562 :             uint16_t hint = index;
        1514         [ -  + ]:     227562 :             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, LOAD_ATTR);
        1515         [ +  - ]:     227562 :             if (DK_IS_UNICODE(dict->ma_keys)) {
        1516                 :     227562 :                 PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint;
        1517         [ -  + ]:     227562 :                 DEOPT_IF(ep->me_key != name, LOAD_ATTR);
        1518                 :     227562 :                 res = ep->me_value;
        1519                 :            :             }
        1520                 :            :             else {
        1521                 :          0 :                 PyDictKeyEntry *ep = DK_ENTRIES(dict->ma_keys) + hint;
        1522         [ #  # ]:          0 :                 DEOPT_IF(ep->me_key != name, LOAD_ATTR);
        1523                 :          0 :                 res = ep->me_value;
        1524                 :            :             }
        1525         [ +  + ]:     227562 :             DEOPT_IF(res == NULL, LOAD_ATTR);
        1526                 :            :             STAT_INC(LOAD_ATTR, hit);
        1527                 :         59 :             Py_INCREF(res);
        1528         [ -  + ]:         59 :             res2 = NULL;
        1529                 :            :             DECREF_INPUTS();
        1530                 :            :         }
        1531                 :            :
        1532                 :            :         inst(LOAD_ATTR_SLOT, (unused/1, type_version/2, index/1, unused/5, owner -- res2 if (oparg & 1), res)) {
        1533                 :            :             assert(cframe.use_tracing == 0);
        1534                 :     375316 :             PyTypeObject *tp = Py_TYPE(owner);
        1535                 :            :             assert(type_version != 0);
        1536         [ +  + ]:     375316 :             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
        1537                 :     374991 :             char *addr = (char *)owner + index;
        1538                 :     374991 :             res = *(PyObject **)addr;
        1539         [ +  + ]:     374991 :             DEOPT_IF(res == NULL, LOAD_ATTR);
        1540                 :            :             STAT_INC(LOAD_ATTR, hit);
        1541                 :     374910 :             Py_INCREF(res);
        1542         [ -  + ]:     374910 :             res2 = NULL;
        1543                 :            :             DECREF_INPUTS();
        1544                 :            :         }
        1545                 :            :
        1546                 :            :         inst(LOAD_ATTR_CLASS, (unused/1, type_version/2, unused/2, descr/4, cls -- res2 if (oparg & 1), res)) {
        1547                 :            :             assert(cframe.use_tracing == 0);
        1548                 :            :
        1549         [ -  + ]:     376321 :             DEOPT_IF(!PyType_Check(cls), LOAD_ATTR);
        1550         [ +  + ]:     376321 :             DEOPT_IF(((PyTypeObject *)cls)->tp_version_tag != type_version,
        1551                 :            :                 LOAD_ATTR);
        1552                 :            :             assert(type_version != 0);
        1553                 :            :
        1554                 :            :             STAT_INC(LOAD_ATTR, hit);
        1555                 :     376319 :             res2 = NULL;
        1556                 :     376319 :             res = descr;
        1557                 :            :             assert(res != NULL);
        1558                 :     376319 :             Py_INCREF(res);
        1559                 :            :             DECREF_INPUTS();
        1560                 :            :         }
        1561                 :            :
        1562                 :            :         inst(LOAD_ATTR_PROPERTY, (unused/1, type_version/2, func_version/2, fget/4, owner -- unused if (oparg & 1), unused)) {
        1563                 :            :             assert(cframe.use_tracing == 0);
        1564         [ -  + ]:      41965 :             DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
        1565                 :            :
        1566                 :      41965 :             PyTypeObject *cls = Py_TYPE(owner);
        1567         [ -  + ]:      41965 :             DEOPT_IF(cls->tp_version_tag != type_version, LOAD_ATTR);
        1568                 :            :             assert(type_version != 0);
        1569                 :            :             assert(Py_IS_TYPE(fget, &PyFunction_Type));
        1570                 :      41965 :             PyFunctionObject *f = (PyFunctionObject *)fget;
        1571                 :            :             assert(func_version != 0);
        1572         [ -  + ]:      41965 :             DEOPT_IF(f->func_version != func_version, LOAD_ATTR);
        1573                 :      41965 :             PyCodeObject *code = (PyCodeObject *)f->func_code;
        1574                 :            :             assert(code->co_argcount == 1);
        1575         [ -  + ]:      41965 :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
        1576                 :            :             STAT_INC(LOAD_ATTR, hit);
        1577                 :      41965 :             Py_INCREF(fget);
        1578                 :      41965 :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 1);
        1579                 :            :             // Manipulate stack directly because we exit with DISPATCH_INLINED().
        1580                 :      41965 :             SET_TOP(NULL);
        1581                 :      41965 :             int shrink_stack = !(oparg & 1);
        1582                 :      41965 :             STACK_SHRINK(shrink_stack);
        1583                 :      41965 :             new_frame->localsplus[0] = owner;
        1584                 :      41965 :             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
        1585                 :      41965 :             DISPATCH_INLINED(new_frame);
        1586                 :            :         }
        1587                 :            :
        1588                 :            :         inst(LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN, (unused/1, type_version/2, func_version/2, getattribute/4, owner -- unused if (oparg & 1), unused)) {
        1589                 :            :             assert(cframe.use_tracing == 0);
        1590         [ #  # ]:          0 :             DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
        1591                 :          0 :             PyTypeObject *cls = Py_TYPE(owner);
        1592         [ #  # ]:          0 :             DEOPT_IF(cls->tp_version_tag != type_version, LOAD_ATTR);
        1593                 :            :             assert(type_version != 0);
        1594                 :            :             assert(Py_IS_TYPE(getattribute, &PyFunction_Type));
        1595                 :          0 :             PyFunctionObject *f = (PyFunctionObject *)getattribute;
        1596                 :            :             assert(func_version != 0);
        1597         [ #  # ]:          0 :             DEOPT_IF(f->func_version != func_version, LOAD_ATTR);
        1598                 :          0 :             PyCodeObject *code = (PyCodeObject *)f->func_code;
        1599                 :            :             assert(code->co_argcount == 2);
        1600         [ #  # ]:          0 :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
        1601                 :            :             STAT_INC(LOAD_ATTR, hit);
        1602                 :            :
        1603                 :          0 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
        1604                 :          0 :             Py_INCREF(f);
        1605                 :          0 :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 2);
        1606                 :            :             // Manipulate stack directly because we exit with DISPATCH_INLINED().
        1607                 :          0 :             SET_TOP(NULL);
        1608                 :          0 :             int shrink_stack = !(oparg & 1);
        1609                 :          0 :             STACK_SHRINK(shrink_stack);
        1610                 :          0 :             new_frame->localsplus[0] = owner;
        1611                 :          0 :             new_frame->localsplus[1] = Py_NewRef(name);
        1612                 :          0 :             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
        1613                 :          0 :             DISPATCH_INLINED(new_frame);
        1614                 :            :         }
        1615                 :            :
        1616                 :            :         inst(STORE_ATTR_INSTANCE_VALUE, (unused/1, type_version/2, index/1, value, owner --)) {
        1617                 :            :             assert(cframe.use_tracing == 0);
        1618                 :     842732 :             PyTypeObject *tp = Py_TYPE(owner);
        1619                 :            :             assert(type_version != 0);
        1620         [ +  + ]:     842732 :             DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
        1621                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
        1622                 :     841574 :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
        1623         [ -  + ]:     841574 :             DEOPT_IF(!_PyDictOrValues_IsValues(dorv), STORE_ATTR);
        1624                 :            :             STAT_INC(STORE_ATTR, hit);
        1625                 :     841574 :             PyDictValues *values = _PyDictOrValues_GetValues(dorv);
        1626                 :     841574 :             PyObject *old_value = values->values[index];
        1627                 :     841574 :             values->values[index] = value;
        1628         [ +  + ]:     841574 :             if (old_value == NULL) {
        1629                 :     569356 :                 _PyDictValues_AddToInsertionOrder(values, index);
        1630                 :            :             }
        1631                 :            :             else {
        1632         [ +  + ]:     272218 :                 Py_DECREF(old_value);
        1633                 :            :             }
        1634         [ -  + ]:     841574 :             Py_DECREF(owner);
        1635                 :            :         }
        1636                 :            :
        1637                 :            :         inst(STORE_ATTR_WITH_HINT, (unused/1, type_version/2, hint/1, value, owner --)) {
        1638                 :            :             assert(cframe.use_tracing == 0);
        1639                 :     319989 :             PyTypeObject *tp = Py_TYPE(owner);
        1640                 :            :             assert(type_version != 0);
        1641         [ +  + ]:     319989 :             DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
        1642                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
        1643                 :     318684 :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
        1644         [ -  + ]:     318684 :             DEOPT_IF(_PyDictOrValues_IsValues(dorv), STORE_ATTR);
        1645                 :     318684 :             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
        1646         [ -  + ]:     318684 :             DEOPT_IF(dict == NULL, STORE_ATTR);
        1647                 :            :             assert(PyDict_CheckExact((PyObject *)dict));
        1648                 :     318684 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
        1649         [ -  + ]:     318684 :             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, STORE_ATTR);
        1650                 :            :             PyObject *old_value;
        1651                 :            :             uint64_t new_version;
        1652         [ +  - ]:     318684 :             if (DK_IS_UNICODE(dict->ma_keys)) {
        1653                 :     318684 :                 PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint;
        1654         [ -  + ]:     318684 :                 DEOPT_IF(ep->me_key != name, STORE_ATTR);
        1655                 :     318684 :                 old_value = ep->me_value;
        1656         [ +  - ]:     318684 :                 DEOPT_IF(old_value == NULL, STORE_ATTR);
        1657                 :          0 :                 new_version = _PyDict_NotifyEvent(tstate->interp, PyDict_EVENT_MODIFIED, dict, name, value);
        1658                 :          0 :                 ep->me_value = value;
        1659                 :            :             }
        1660                 :            :             else {
        1661                 :          0 :                 PyDictKeyEntry *ep = DK_ENTRIES(dict->ma_keys) + hint;
        1662         [ #  # ]:          0 :                 DEOPT_IF(ep->me_key != name, STORE_ATTR);
        1663                 :          0 :                 old_value = ep->me_value;
        1664         [ #  # ]:          0 :                 DEOPT_IF(old_value == NULL, STORE_ATTR);
        1665                 :          0 :                 new_version = _PyDict_NotifyEvent(tstate->interp, PyDict_EVENT_MODIFIED, dict, name, value);
        1666                 :          0 :                 ep->me_value = value;
        1667                 :            :             }
        1668         [ #  # ]:          0 :             Py_DECREF(old_value);
        1669                 :            :             STAT_INC(STORE_ATTR, hit);
        1670                 :            :             /* Ensure dict is GC tracked if it needs to be */
        1671   [ #  #  #  # ]:          0 :             if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(value)) {
        1672                 :          0 :                 _PyObject_GC_TRACK(dict);
        1673                 :            :             }
        1674                 :            :             /* PEP 509 */
        1675                 :          0 :             dict->ma_version_tag = new_version;
        1676         [ #  # ]:          0 :             Py_DECREF(owner);
        1677                 :            :         }
        1678                 :            :
        1679                 :            :         inst(STORE_ATTR_SLOT, (unused/1, type_version/2, index/1, value, owner --)) {
        1680                 :            :             assert(cframe.use_tracing == 0);
        1681                 :     266076 :             PyTypeObject *tp = Py_TYPE(owner);
        1682                 :            :             assert(type_version != 0);
        1683         [ +  + ]:     266076 :             DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
        1684                 :     266015 :             char *addr = (char *)owner + index;
        1685                 :            :             STAT_INC(STORE_ATTR, hit);
        1686                 :     266015 :             PyObject *old_value = *(PyObject **)addr;
        1687                 :     266015 :             *(PyObject **)addr = value;
        1688   [ +  +  -  + ]:     266015 :             Py_XDECREF(old_value);
        1689         [ -  + ]:     266015 :             Py_DECREF(owner);
        1690                 :            :         }
        1691                 :            :
        1692                 :            :         inst(COMPARE_OP, (unused/1, left, right -- res)) {
        1693                 :            :             STAT_INC(COMPARE_OP, deferred);
        1694                 :            :             assert((oparg >> 4) <= Py_GE);
        1695                 :     163293 :             res = PyObject_RichCompare(left, right, oparg>>4);
        1696                 :            :             DECREF_INPUTS();
        1697         [ -  + ]:     163293 :             ERROR_IF(res == NULL, error);
        1698                 :            :         }
        1699                 :            :
        1700                 :            :         // No cache size here, since this is a family of super-instructions.
        1701                 :            :         family(compare_and_branch) = {
        1702                 :            :             COMPARE_AND_BRANCH,
        1703                 :            :             COMPARE_AND_BRANCH_FLOAT,
        1704                 :            :             COMPARE_AND_BRANCH_INT,
        1705                 :            :             COMPARE_AND_BRANCH_STR,
        1706                 :            :         };
        1707                 :            :
        1708                 :            :         inst(COMPARE_AND_BRANCH, (unused/2, left, right -- )) {
        1709                 :            :             #if ENABLE_SPECIALIZATION
        1710                 :     143382 :             _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
        1711         [ +  + ]:     143382 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
        1712                 :            :                 assert(cframe.use_tracing == 0);
        1713                 :       3834 :                 next_instr--;
        1714                 :       3834 :                 _Py_Specialize_CompareAndBranch(left, right, next_instr, oparg);
        1715                 :       3834 :                 DISPATCH_SAME_OPARG();
        1716                 :            :             }
        1717                 :            :             STAT_INC(COMPARE_AND_BRANCH, deferred);
        1718                 :     139548 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
        1719                 :            :             #endif  /* ENABLE_SPECIALIZATION */
        1720                 :            :             assert((oparg >> 4) <= Py_GE);
        1721                 :     139548 :             PyObject *cond = PyObject_RichCompare(left, right, oparg>>4);
        1722                 :            :             DECREF_INPUTS();
        1723         [ -  + ]:     139548 :             ERROR_IF(cond == NULL, error);
        1724                 :            :             assert(next_instr[1].op.code == POP_JUMP_IF_FALSE ||
        1725                 :            :                    next_instr[1].op.code == POP_JUMP_IF_TRUE);
        1726                 :     139548 :             bool jump_on_true = next_instr[1].op.code == POP_JUMP_IF_TRUE;
        1727                 :     139548 :             int offset = next_instr[1].op.arg;
        1728                 :     139548 :             int err = PyObject_IsTrue(cond);
        1729         [ -  + ]:     139548 :             Py_DECREF(cond);
        1730         [ -  + ]:     139548 :             ERROR_IF(err < 0, error);
        1731         [ +  + ]:     139548 :             if (jump_on_true == (err != 0)) {
        1732                 :     123969 :                 JUMPBY(offset);
        1733                 :            :             }
        1734                 :            :         }
        1735                 :            :
        1736                 :            :         inst(COMPARE_AND_BRANCH_FLOAT, (unused/2, left, right -- )) {
        1737                 :            :             assert(cframe.use_tracing == 0);
        1738         [ +  + ]:      92283 :             DEOPT_IF(!PyFloat_CheckExact(left), COMPARE_AND_BRANCH);
        1739         [ +  + ]:      92055 :             DEOPT_IF(!PyFloat_CheckExact(right), COMPARE_AND_BRANCH);
        1740                 :            :             STAT_INC(COMPARE_AND_BRANCH, hit);
        1741                 :      91957 :             double dleft = PyFloat_AS_DOUBLE(left);
        1742                 :      91957 :             double dright = PyFloat_AS_DOUBLE(right);
        1743                 :            :             // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg
        1744         [ +  + ]:      91957 :             int sign_ish = COMPARISON_BIT(dleft, dright);
        1745         [ +  + ]:      91957 :             _Py_DECREF_SPECIALIZED(left, _PyFloat_ExactDealloc);
        1746         [ -  + ]:      91957 :             _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
        1747         [ +  + ]:      91957 :             if (sign_ish & oparg) {
        1748                 :      89905 :                 int offset = next_instr[1].op.arg;
        1749                 :      89905 :                 JUMPBY(offset);
        1750                 :            :             }
        1751                 :            :         }
        1752                 :            :
        1753                 :            :         // Similar to COMPARE_AND_BRANCH_FLOAT
        1754                 :            :         inst(COMPARE_AND_BRANCH_INT, (unused/2, left, right -- )) {
        1755                 :            :             assert(cframe.use_tracing == 0);
        1756         [ -  + ]:    2025806 :             DEOPT_IF(!PyLong_CheckExact(left), COMPARE_AND_BRANCH);
        1757         [ -  + ]:    2025806 :             DEOPT_IF(!PyLong_CheckExact(right), COMPARE_AND_BRANCH);
        1758         [ +  + ]:    2025806 :             DEOPT_IF((size_t)(Py_SIZE(left) + 1) > 2, COMPARE_AND_BRANCH);
        1759         [ +  + ]:    1993166 :             DEOPT_IF((size_t)(Py_SIZE(right) + 1) > 2, COMPARE_AND_BRANCH);
        1760                 :            :             STAT_INC(COMPARE_AND_BRANCH, hit);
        1761                 :            :             assert(Py_ABS(Py_SIZE(left)) <= 1 && Py_ABS(Py_SIZE(right)) <= 1);
        1762                 :    1993163 :             Py_ssize_t ileft = Py_SIZE(left) * ((PyLongObject *)left)->long_value.ob_digit[0];
        1763                 :    1993163 :             Py_ssize_t iright = Py_SIZE(right) * ((PyLongObject *)right)->long_value.ob_digit[0];
        1764                 :            :             // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg
        1765         [ +  + ]:    1993163 :             int sign_ish = COMPARISON_BIT(ileft, iright);
        1766         [ +  + ]:    1993163 :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
        1767         [ +  + ]:    1993163 :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
        1768         [ +  + ]:    1993163 :             if (sign_ish & oparg) {
        1769                 :    1499413 :                 int offset = next_instr[1].op.arg;
        1770                 :    1499413 :                 JUMPBY(offset);
        1771                 :            :             }
        1772                 :            :         }
        1773                 :            :
        1774                 :            :         // Similar to COMPARE_AND_BRANCH_FLOAT, but for ==, != only
        1775                 :            :         inst(COMPARE_AND_BRANCH_STR, (unused/2, left, right -- )) {
        1776                 :            :             assert(cframe.use_tracing == 0);
        1777         [ +  + ]:      34573 :             DEOPT_IF(!PyUnicode_CheckExact(left), COMPARE_AND_BRANCH);
        1778         [ +  + ]:      34481 :             DEOPT_IF(!PyUnicode_CheckExact(right), COMPARE_AND_BRANCH);
        1779                 :            :             STAT_INC(COMPARE_AND_BRANCH, hit);
        1780                 :      34391 :             int res = _PyUnicode_Equal(left, right);
        1781                 :            :             assert((oparg >>4) == Py_EQ || (oparg >>4) == Py_NE);
        1782         [ +  + ]:      34391 :             _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
        1783         [ +  + ]:      34391 :             _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
        1784                 :            :             assert(res == 0 || res == 1);
        1785                 :            :             assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS);
        1786                 :            :             assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS);
        1787         [ +  + ]:      34391 :             if ((res + COMPARISON_NOT_EQUALS) & oparg) {
        1788                 :      30448 :                 int offset = next_instr[1].op.arg;
        1789                 :      30448 :                 JUMPBY(offset);
        1790                 :            :             }
        1791                 :            :         }
        1792                 :            :
        1793                 :            :         inst(IS_OP, (left, right -- b)) {
        1794         [ +  + ]:     242056 :             int res = Py_Is(left, right) ^ oparg;
        1795                 :            :             DECREF_INPUTS();
        1796         [ +  + ]:     242056 :             b = Py_NewRef(res ? Py_True : Py_False);
        1797                 :            :         }
        1798                 :            :
        1799                 :            :         inst(CONTAINS_OP, (left, right -- b)) {
        1800                 :      66972 :             int res = PySequence_Contains(right, left);
        1801                 :            :             DECREF_INPUTS();
        1802         [ -  + ]:      66972 :             ERROR_IF(res < 0, error);
        1803         [ +  + ]:      66972 :             b = Py_NewRef((res^oparg) ? Py_True : Py_False);
        1804                 :            :         }
        1805                 :            :
        1806                 :            :         inst(CHECK_EG_MATCH, (exc_value, match_type -- rest, match)) {
        1807         [ #  # ]:          0 :             if (check_except_star_type_valid(tstate, match_type) < 0) {
        1808                 :            :                 DECREF_INPUTS();
        1809                 :          0 :                 ERROR_IF(true, error);
        1810                 :            :             }
        1811                 :            :
        1812                 :          0 :             match = NULL;
        1813                 :          0 :             rest = NULL;
        1814                 :          0 :             int res = exception_group_match(exc_value, match_type,
        1815                 :            :                                             &match, &rest);
        1816                 :            :             DECREF_INPUTS();
        1817         [ #  # ]:          0 :             ERROR_IF(res < 0, error);
        1818                 :            :
        1819                 :            :             assert((match == NULL) == (rest == NULL));
        1820         [ #  # ]:          0 :             ERROR_IF(match == NULL, error);
        1821                 :            :
        1822         [ #  # ]:          0 :             if (!Py_IsNone(match)) {
        1823                 :          0 :                 PyErr_SetExcInfo(NULL, Py_NewRef(match), NULL);
        1824                 :            :             }
        1825                 :            :         }
        1826                 :            :
        1827                 :            :         inst(CHECK_EXC_MATCH, (left, right -- left, b)) {
        1828                 :            :             assert(PyExceptionInstance_Check(left));
        1829         [ -  + ]:     101696 :             if (check_except_type_valid(tstate, right) < 0) {
        1830                 :            :                  DECREF_INPUTS();
        1831                 :          0 :                  ERROR_IF(true, error);
        1832                 :            :             }
        1833                 :            :
        1834                 :     101696 :             int res = PyErr_GivenExceptionMatches(left, right);
        1835                 :            :             DECREF_INPUTS();
        1836         [ +  + ]:     101696 :             b = Py_NewRef(res ? Py_True : Py_False);
        1837                 :            :         }
        1838                 :            :
        1839                 :            :          inst(IMPORT_NAME, (level, fromlist -- res)) {
        1840                 :       3157 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
        1841                 :       3157 :             res = import_name(tstate, frame, name, fromlist, level);
        1842                 :            :             DECREF_INPUTS();
        1843         [ +  + ]:       3157 :             ERROR_IF(res == NULL, error);
        1844                 :            :         }
        1845                 :            :
        1846                 :            :         inst(IMPORT_FROM, (from -- from, res)) {
        1847                 :       2022 :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
        1848                 :       2022 :             res = import_from(tstate, from, name);
        1849         [ +  + ]:       2022 :             ERROR_IF(res == NULL, error);
        1850                 :            :         }
        1851                 :            :
        1852                 :            :         inst(JUMP_FORWARD, (--)) {
        1853                 :     101239 :             JUMPBY(oparg);
        1854                 :            :         }
        1855                 :            :
        1856                 :            :         inst(JUMP_BACKWARD, (--)) {
        1857                 :            :             assert(oparg < INSTR_OFFSET());
        1858         [ +  + ]:    3172588 :             JUMPBY(-oparg);
        1859                 :            :             CHECK_EVAL_BREAKER();
        1860                 :            :         }
        1861                 :            :
        1862                 :            :         inst(POP_JUMP_IF_FALSE, (cond -- )) {
        1863         [ +  + ]:    1257996 :             if (Py_IsTrue(cond)) {
        1864                 :     930004 :                 _Py_DECREF_NO_DEALLOC(cond);
        1865                 :            :             }
        1866         [ +  + ]:     327992 :             else if (Py_IsFalse(cond)) {
        1867                 :     250633 :                 _Py_DECREF_NO_DEALLOC(cond);
        1868                 :     250633 :                 JUMPBY(oparg);
        1869                 :            :             }
        1870                 :            :             else {
        1871                 :      77359 :                 int err = PyObject_IsTrue(cond);
        1872                 :            :                 DECREF_INPUTS();
        1873         [ +  + ]:      77359 :                 if (err == 0) {
        1874                 :      38757 :                     JUMPBY(oparg);
        1875                 :            :                 }
        1876                 :            :                 else {
        1877         [ -  + ]:      38602 :                     ERROR_IF(err < 0, error);
        1878                 :            :                 }
        1879                 :            :             }
        1880                 :            :         }
        1881                 :            :
        1882                 :            :         inst(POP_JUMP_IF_TRUE, (cond -- )) {
        1883         [ +  + ]:     667438 :             if (Py_IsFalse(cond)) {
        1884                 :      32082 :                 _Py_DECREF_NO_DEALLOC(cond);
        1885                 :            :             }
        1886         [ +  + ]:     635356 :             else if (Py_IsTrue(cond)) {
        1887                 :     103126 :                 _Py_DECREF_NO_DEALLOC(cond);
        1888                 :     103126 :                 JUMPBY(oparg);
        1889                 :            :             }
        1890                 :            :             else {
        1891                 :     532230 :                 int err = PyObject_IsTrue(cond);
        1892                 :            :                 DECREF_INPUTS();
        1893         [ +  + ]:     532230 :                 if (err > 0) {
        1894                 :     514831 :                     JUMPBY(oparg);
        1895                 :            :                 }
        1896                 :            :                 else {
        1897         [ -  + ]:      17399 :                     ERROR_IF(err < 0, error);
        1898                 :            :                 }
        1899                 :            :             }
        1900                 :            :         }
        1901                 :            :
        1902                 :            :         inst(POP_JUMP_IF_NOT_NONE, (value -- )) {
        1903         [ +  + ]:     513172 :             if (!Py_IsNone(value)) {
        1904                 :            :                 DECREF_INPUTS();
        1905                 :     146583 :                 JUMPBY(oparg);
        1906                 :            :             }
        1907                 :            :             else {
        1908                 :     366589 :                 _Py_DECREF_NO_DEALLOC(value);
        1909                 :            :             }
        1910                 :            :         }
        1911                 :            :
        1912                 :            :         inst(POP_JUMP_IF_NONE, (value -- )) {
        1913         [ +  + ]:     186654 :             if (Py_IsNone(value)) {
        1914                 :     162760 :                 _Py_DECREF_NO_DEALLOC(value);
        1915                 :     162760 :                 JUMPBY(oparg);
        1916                 :            :             }
        1917                 :            :             else {
        1918                 :            :                 DECREF_INPUTS();
        1919                 :            :             }
        1920                 :            :         }
        1921                 :            :
        1922                 :            :         inst(JUMP_IF_FALSE_OR_POP, (cond -- cond if (jump))) {
        1923                 :      99575 :             bool jump = false;
        1924                 :            :             int err;
        1925         [ +  + ]:      99575 :             if (Py_IsTrue(cond)) {
        1926                 :      85386 :                 _Py_DECREF_NO_DEALLOC(cond);
        1927                 :            :             }
        1928         [ +  + ]:      14189 :             else if (Py_IsFalse(cond)) {
        1929                 :      12041 :                 JUMPBY(oparg);
        1930                 :      12041 :                 jump = true;
        1931                 :            :             }
        1932                 :            :             else {
        1933                 :       2148 :                 err = PyObject_IsTrue(cond);
        1934         [ +  + ]:       2148 :                 if (err > 0) {
        1935         [ +  + ]:        959 :                     Py_DECREF(cond);
        1936                 :            :                 }
        1937         [ +  - ]:       1189 :                 else if (err == 0) {
        1938                 :       1189 :                     JUMPBY(oparg);
        1939                 :       1189 :                     jump = true;
        1940                 :            :                 }
        1941                 :            :                 else {
        1942                 :          0 :                     goto error;
        1943                 :            :                 }
        1944                 :            :             }
        1945                 :            :         }
        1946                 :            :
        1947                 :            :         inst(JUMP_IF_TRUE_OR_POP, (cond -- cond if (jump))) {
        1948                 :      18928 :             bool jump = false;
        1949                 :            :             int err;
        1950         [ +  + ]:      18928 :             if (Py_IsFalse(cond)) {
        1951                 :       1098 :                 _Py_DECREF_NO_DEALLOC(cond);
        1952                 :            :             }
        1953         [ +  + ]:      17830 :             else if (Py_IsTrue(cond)) {
        1954                 :        167 :                 JUMPBY(oparg);
        1955                 :        167 :                 jump = true;
        1956                 :            :             }
        1957                 :            :             else {
        1958                 :      17663 :                 err = PyObject_IsTrue(cond);
        1959         [ +  + ]:      17663 :                 if (err > 0) {
        1960                 :      16845 :                     JUMPBY(oparg);
        1961                 :      16845 :                     jump = true;
        1962                 :            :                 }
        1963         [ +  - ]:        818 :                 else if (err == 0) {
        1964         [ -  + ]:        818 :                     Py_DECREF(cond);
        1965                 :            :                 }
        1966                 :            :                 else {
        1967                 :          0 :                     goto error;
        1968                 :            :                 }
        1969                 :            :             }
        1970                 :            :         }
        1971                 :            :
        1972                 :            :         inst(JUMP_BACKWARD_NO_INTERRUPT, (--)) {
        1973                 :            :             /* This bytecode is used in the `yield from` or `await` loop.
        1974                 :            :              * If there is an interrupt, we want it handled in the innermost
        1975                 :            :              * generator or coroutine, so we deliberately do not check it here.
        1976                 :            :              * (see bpo-30039).
        1977                 :            :              */
        1978                 :        339 :             JUMPBY(-oparg);
        1979                 :            :         }
        1980                 :            :
        1981                 :            :         inst(GET_LEN, (obj -- obj, len_o)) {
        1982                 :            :             // PUSH(len(TOS))
        1983                 :        408 :             Py_ssize_t len_i = PyObject_Length(obj);
        1984         [ -  + ]:        408 :             ERROR_IF(len_i < 0, error);
        1985                 :        408 :             len_o = PyLong_FromSsize_t(len_i);
        1986         [ -  + ]:        408 :             ERROR_IF(len_o == NULL, error);
        1987                 :            :         }
        1988                 :            :
        1989                 :            :         inst(MATCH_CLASS, (subject, type, names -- attrs)) {
        1990                 :            :             // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or
        1991                 :            :             // None on failure.
        1992                 :            :             assert(PyTuple_CheckExact(names));
        1993                 :         26 :             attrs = match_class(tstate, subject, type, oparg, names);
        1994                 :            :             DECREF_INPUTS();
        1995         [ +  + ]:         26 :             if (attrs) {
        1996                 :            :                 assert(PyTuple_CheckExact(attrs));  // Success!
        1997                 :            :             }
        1998                 :            :             else {
        1999         [ -  + ]:         16 :                 ERROR_IF(_PyErr_Occurred(tstate), error);  // Error!
        2000                 :         16 :                 attrs = Py_NewRef(Py_None);  // Failure!
        2001                 :            :             }
        2002                 :            :         }
        2003                 :            :
        2004                 :            :         inst(MATCH_MAPPING, (subject -- subject, res)) {
        2005                 :          0 :             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING;
        2006         [ #  # ]:          0 :             res = Py_NewRef(match ? Py_True : Py_False);
        2007                 :            :             PREDICT(POP_JUMP_IF_FALSE);
        2008                 :            :         }
        2009                 :            :
        2010                 :            :         inst(MATCH_SEQUENCE, (subject -- subject, res)) {
        2011                 :        509 :             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE;
        2012         [ +  - ]:        509 :             res = Py_NewRef(match ? Py_True : Py_False);
        2013                 :            :             PREDICT(POP_JUMP_IF_FALSE);
        2014                 :            :         }
        2015                 :            :
        2016                 :            :         inst(MATCH_KEYS, (subject, keys -- subject, keys, values_or_none)) {
        2017                 :            :             // On successful match, PUSH(values). Otherwise, PUSH(None).
        2018                 :          0 :             values_or_none = match_keys(tstate, subject, keys);
        2019         [ #  # ]:          0 :             ERROR_IF(values_or_none == NULL, error);
        2020                 :            :         }
        2021                 :            :
        2022                 :            :         inst(GET_ITER, (iterable -- iter)) {
        2023                 :            :             /* before: [obj]; after [getiter(obj)] */
        2024                 :    1629120 :             iter = PyObject_GetIter(iterable);
        2025                 :            :             DECREF_INPUTS();
        2026         [ -  + ]:    1629120 :             ERROR_IF(iter == NULL, error);
        2027                 :            :         }
        2028                 :            :
        2029                 :            :         inst(GET_YIELD_FROM_ITER, (iterable -- iter)) {
        2030                 :            :             /* before: [obj]; after [getiter(obj)] */
        2031         [ -  + ]:         38 :             if (PyCoro_CheckExact(iterable)) {
        2032                 :            :                 /* `iterable` is a coroutine */
        2033         [ #  # ]:          0 :                 if (!(frame->f_code->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
        2034                 :            :                     /* and it is used in a 'yield from' expression of a
        2035                 :            :                        regular generator. */
        2036                 :          0 :                     _PyErr_SetString(tstate, PyExc_TypeError,
        2037                 :            :                                      "cannot 'yield from' a coroutine object "
        2038                 :            :                                      "in a non-coroutine generator");
        2039                 :          0 :                     goto error;
        2040                 :            :                 }
        2041                 :          0 :                 iter = iterable;
        2042                 :            :             }
        2043         [ +  + ]:         38 :             else if (PyGen_CheckExact(iterable)) {
        2044                 :         27 :                 iter = iterable;
        2045                 :            :             }
        2046                 :            :             else {
        2047                 :            :                 /* `iterable` is not a generator. */
        2048                 :         11 :                 iter = PyObject_GetIter(iterable);
        2049         [ -  + ]:         11 :                 if (iter == NULL) {
        2050                 :          0 :                     goto error;
        2051                 :            :                 }
        2052                 :            :                 DECREF_INPUTS();
        2053                 :            :             }
        2054                 :            :             PREDICT(LOAD_CONST);
        2055                 :            :         }
        2056                 :            :
        2057                 :            :         // Most members of this family are "secretly" super-instructions.
        2058                 :            :         // When the loop is exhausted, they jump, and the jump target is
        2059                 :            :         // always END_FOR, which pops two values off the stack.
        2060                 :            :         // This is optimized by skipping that instruction and combining
        2061                 :            :         // its effect (popping 'iter' instead of pushing 'next'.)
        2062                 :            :
        2063                 :            :         family(for_iter, INLINE_CACHE_ENTRIES_FOR_ITER) = {
        2064                 :            :             FOR_ITER,
        2065                 :            :             FOR_ITER_LIST,
        2066                 :            :             FOR_ITER_TUPLE,
        2067                 :            :             FOR_ITER_RANGE,
        2068                 :            :             FOR_ITER_GEN,
        2069                 :            :         };
        2070                 :            :
        2071                 :            :         inst(FOR_ITER, (unused/1, iter -- iter, next)) {
        2072                 :            :             #if ENABLE_SPECIALIZATION
        2073                 :    3537147 :             _PyForIterCache *cache = (_PyForIterCache *)next_instr;
        2074         [ +  + ]:    3537147 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
        2075                 :            :                 assert(cframe.use_tracing == 0);
        2076                 :       3275 :                 next_instr--;
        2077                 :       3275 :                 _Py_Specialize_ForIter(iter, next_instr, oparg);
        2078                 :       3275 :                 DISPATCH_SAME_OPARG();
        2079                 :            :             }
        2080                 :            :             STAT_INC(FOR_ITER, deferred);
        2081                 :    3533872 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
        2082                 :            :             #endif  /* ENABLE_SPECIALIZATION */
        2083                 :            :             /* before: [iter]; after: [iter, iter()] *or* [] (and jump over END_FOR.) */
        2084                 :    3533872 :             next = (*Py_TYPE(iter)->tp_iternext)(iter);
        2085         [ +  + ]:    3533872 :             if (next == NULL) {
        2086         [ -  + ]:    1598645 :                 if (_PyErr_Occurred(tstate)) {
        2087         [ #  # ]:          0 :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) {
        2088                 :          0 :                         goto error;
        2089                 :            :                     }
        2090         [ #  # ]:          0 :                     else if (tstate->c_tracefunc != NULL) {
        2091                 :          0 :                         call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, frame);
        2092                 :            :                     }
        2093                 :          0 :                     _PyErr_Clear(tstate);
        2094                 :            :                 }
        2095                 :            :                 /* iterator ended normally */
        2096                 :            :                 assert(next_instr[INLINE_CACHE_ENTRIES_FOR_ITER + oparg].op.code == END_FOR);
        2097         [ +  + ]:    1598645 :                 Py_DECREF(iter);
        2098                 :    1598645 :                 STACK_SHRINK(1);
        2099                 :            :                 /* Jump forward oparg, then skip following END_FOR instruction */
        2100                 :    1598645 :                 JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
        2101                 :    1598645 :                 DISPATCH();
        2102                 :            :             }
        2103                 :            :             // Common case: no jump, leave it to the code generator
        2104                 :            :         }
        2105                 :            :
        2106                 :            :         inst(FOR_ITER_LIST, (unused/1, iter -- iter, next)) {
        2107                 :            :             assert(cframe.use_tracing == 0);
        2108         [ +  + ]:     586273 :             DEOPT_IF(Py_TYPE(iter) != &PyListIter_Type, FOR_ITER);
        2109                 :     585806 :             _PyListIterObject *it = (_PyListIterObject *)iter;
        2110                 :            :             STAT_INC(FOR_ITER, hit);
        2111                 :     585806 :             PyListObject *seq = it->it_seq;
        2112         [ +  - ]:     585806 :             if (seq) {
        2113         [ +  + ]:     585806 :                 if (it->it_index < PyList_GET_SIZE(seq)) {
        2114                 :     578555 :                     next = Py_NewRef(PyList_GET_ITEM(seq, it->it_index++));
        2115                 :     578555 :                     goto end_for_iter_list;  // End of this instruction
        2116                 :            :                 }
        2117                 :       7251 :                 it->it_seq = NULL;
        2118         [ +  + ]:       7251 :                 Py_DECREF(seq);
        2119                 :            :             }
        2120         [ +  + ]:       7251 :             Py_DECREF(iter);
        2121                 :       7251 :             STACK_SHRINK(1);
        2122                 :            :             /* Jump forward oparg, then skip following END_FOR instruction */
        2123                 :       7251 :             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
        2124                 :       7251 :             DISPATCH();
        2125                 :     578555 :         end_for_iter_list:
        2126                 :            :             // Common case: no jump, leave it to the code generator
        2127                 :            :         }
        2128                 :            :
        2129                 :            :         inst(FOR_ITER_TUPLE, (unused/1, iter -- iter, next)) {
        2130                 :            :             assert(cframe.use_tracing == 0);
        2131                 :      31091 :             _PyTupleIterObject *it = (_PyTupleIterObject *)iter;
        2132         [ +  + ]:      31091 :             DEOPT_IF(Py_TYPE(it) != &PyTupleIter_Type, FOR_ITER);
        2133                 :            :             STAT_INC(FOR_ITER, hit);
        2134                 :      30993 :             PyTupleObject *seq = it->it_seq;
        2135         [ +  - ]:      30993 :             if (seq) {
        2136         [ +  + ]:      30993 :                 if (it->it_index < PyTuple_GET_SIZE(seq)) {
        2137                 :      21063 :                     next = Py_NewRef(PyTuple_GET_ITEM(seq, it->it_index++));
        2138                 :      21063 :                     goto end_for_iter_tuple;  // End of this instruction
        2139                 :            :                 }
        2140                 :       9930 :                 it->it_seq = NULL;
        2141         [ +  + ]:       9930 :                 Py_DECREF(seq);
        2142                 :            :             }
        2143         [ +  + ]:       9930 :             Py_DECREF(iter);
        2144                 :       9930 :             STACK_SHRINK(1);
        2145                 :            :             /* Jump forward oparg, then skip following END_FOR instruction */
        2146                 :       9930 :             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
        2147                 :       9930 :             DISPATCH();
        2148                 :      21063 :         end_for_iter_tuple:
        2149                 :            :             // Common case: no jump, leave it to the code generator
        2150                 :            :         }
        2151                 :            :
        2152                 :            :         inst(FOR_ITER_RANGE, (unused/1, iter -- iter, next)) {
        2153                 :            :             assert(cframe.use_tracing == 0);
        2154                 :     594262 :             _PyRangeIterObject *r = (_PyRangeIterObject *)iter;
        2155         [ +  + ]:     594262 :             DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER);
        2156                 :            :             STAT_INC(FOR_ITER, hit);
        2157         [ +  + ]:     594209 :             if (r->len <= 0) {
        2158                 :       6989 :                 STACK_SHRINK(1);
        2159         [ +  + ]:       6989 :                 Py_DECREF(r);
        2160                 :            :                 // Jump over END_FOR instruction.
        2161                 :       6989 :                 JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
        2162                 :       6989 :                 DISPATCH();
        2163                 :            :             }
        2164                 :     587220 :             long value = r->start;
        2165                 :     587220 :             r->start = value + r->step;
        2166                 :     587220 :             r->len--;
        2167                 :     587220 :             next = PyLong_FromLong(value);
        2168         [ -  + ]:     587220 :             if (next == NULL) {
        2169                 :          0 :                 goto error;
        2170                 :            :             }
        2171                 :            :         }
        2172                 :            :
        2173                 :            :         inst(FOR_ITER_GEN, (unused/1, iter -- iter, unused)) {
        2174                 :            :             assert(cframe.use_tracing == 0);
        2175                 :       5388 :             PyGenObject *gen = (PyGenObject *)iter;
        2176         [ -  + ]:       5388 :             DEOPT_IF(Py_TYPE(gen) != &PyGen_Type, FOR_ITER);
        2177         [ -  + ]:       5388 :             DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, FOR_ITER);
        2178                 :            :             STAT_INC(FOR_ITER, hit);
        2179                 :       5388 :             _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
        2180                 :       5388 :             frame->yield_offset = oparg;
        2181                 :       5388 :             _PyFrame_StackPush(gen_frame, Py_NewRef(Py_None));
        2182                 :       5388 :             gen->gi_frame_state = FRAME_EXECUTING;
        2183                 :       5388 :             gen->gi_exc_state.previous_item = tstate->exc_info;
        2184                 :       5388 :             tstate->exc_info = &gen->gi_exc_state;
        2185                 :       5388 :             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg);
        2186                 :            :             assert(next_instr->op.code == END_FOR);
        2187                 :       5388 :             DISPATCH_INLINED(gen_frame);
        2188                 :            :         }
        2189                 :            :
        2190                 :            :         inst(BEFORE_ASYNC_WITH, (mgr -- exit, res)) {
        2191                 :          0 :             PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__aenter__));
        2192         [ #  # ]:          0 :             if (enter == NULL) {
        2193         [ #  # ]:          0 :                 if (!_PyErr_Occurred(tstate)) {
        2194                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
        2195                 :            :                                   "'%.200s' object does not support the "
        2196                 :            :                                   "asynchronous context manager protocol",
        2197                 :          0 :                                   Py_TYPE(mgr)->tp_name);
        2198                 :            :                 }
        2199                 :          0 :                 goto error;
        2200                 :            :             }
        2201                 :          0 :             exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__aexit__));
        2202         [ #  # ]:          0 :             if (exit == NULL) {
        2203         [ #  # ]:          0 :                 if (!_PyErr_Occurred(tstate)) {
        2204                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
        2205                 :            :                                   "'%.200s' object does not support the "
        2206                 :            :                                   "asynchronous context manager protocol "
        2207                 :            :                                   "(missed __aexit__ method)",
        2208                 :          0 :                                   Py_TYPE(mgr)->tp_name);
        2209                 :            :                 }
        2210         [ #  # ]:          0 :                 Py_DECREF(enter);
        2211                 :          0 :                 goto error;
        2212                 :            :             }
        2213                 :            :             DECREF_INPUTS();
        2214                 :          0 :             res = _PyObject_CallNoArgs(enter);
        2215         [ #  # ]:          0 :             Py_DECREF(enter);
        2216         [ #  # ]:          0 :             if (res == NULL) {
        2217         [ #  # ]:          0 :                 Py_DECREF(exit);
        2218                 :          0 :                 ERROR_IF(true, error);
        2219                 :            :             }
        2220                 :            :             PREDICT(GET_AWAITABLE);
        2221                 :            :         }
        2222                 :            :
        2223                 :            :         inst(BEFORE_WITH, (mgr -- exit, res)) {
        2224                 :            :             /* pop the context manager, push its __exit__ and the
        2225                 :            :              * value returned from calling its __enter__
        2226                 :            :              */
        2227                 :     106669 :             PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__enter__));
        2228         [ -  + ]:     106669 :             if (enter == NULL) {
        2229         [ #  # ]:          0 :                 if (!_PyErr_Occurred(tstate)) {
        2230                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
        2231                 :            :                                   "'%.200s' object does not support the "
        2232                 :            :                                   "context manager protocol",
        2233                 :          0 :                                   Py_TYPE(mgr)->tp_name);
        2234                 :            :                 }
        2235                 :          0 :                 goto error;
        2236                 :            :             }
        2237                 :     106669 :             exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__exit__));
        2238         [ -  + ]:     106669 :             if (exit == NULL) {
        2239         [ #  # ]:          0 :                 if (!_PyErr_Occurred(tstate)) {
        2240                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
        2241                 :            :                                   "'%.200s' object does not support the "
        2242                 :            :                                   "context manager protocol "
        2243                 :            :                                   "(missed __exit__ method)",
        2244                 :          0 :                                   Py_TYPE(mgr)->tp_name);
        2245                 :            :                 }
        2246         [ #  # ]:          0 :                 Py_DECREF(enter);
        2247                 :          0 :                 goto error;
        2248                 :            :             }
        2249                 :            :             DECREF_INPUTS();
        2250                 :     106669 :             res = _PyObject_CallNoArgs(enter);
        2251         [ +  - ]:     106669 :             Py_DECREF(enter);
        2252         [ -  + ]:     106669 :             if (res == NULL) {
        2253         [ #  # ]:          0 :                 Py_DECREF(exit);
        2254                 :          0 :                 ERROR_IF(true, error);
        2255                 :            :             }
        2256                 :            :         }
        2257                 :            :
        2258                 :            :         inst(WITH_EXCEPT_START, (exit_func, lasti, unused, val -- exit_func, lasti, unused, val, res)) {
        2259                 :            :             /* At the top of the stack are 4 values:
        2260                 :            :                - val: TOP = exc_info()
        2261                 :            :                - unused: SECOND = previous exception
        2262                 :            :                - lasti: THIRD = lasti of exception in exc_info()
        2263                 :            :                - exit_func: FOURTH = the context.__exit__ bound method
        2264                 :            :                We call FOURTH(type(TOP), TOP, GetTraceback(TOP)).
        2265                 :            :                Then we push the __exit__ return value.
        2266                 :            :             */
        2267                 :            :             PyObject *exc, *tb;
        2268                 :            :
        2269                 :            :             assert(val && PyExceptionInstance_Check(val));
        2270                 :        293 :             exc = PyExceptionInstance_Class(val);
        2271                 :        293 :             tb = PyException_GetTraceback(val);
        2272   [ +  -  -  + ]:        293 :             Py_XDECREF(tb);
        2273                 :            :             assert(PyLong_Check(lasti));
        2274                 :            :             (void)lasti; // Shut up compiler warning if asserts are off
        2275                 :        293 :             PyObject *stack[4] = {NULL, exc, val, tb};
        2276                 :        293 :             res = PyObject_Vectorcall(exit_func, stack + 1,
        2277                 :            :                     3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
        2278         [ -  + ]:        293 :             ERROR_IF(res == NULL, error);
        2279                 :            :         }
        2280                 :            :
        2281                 :            :         inst(PUSH_EXC_INFO, (new_exc -- prev_exc, new_exc)) {
        2282                 :     101972 :             _PyErr_StackItem *exc_info = tstate->exc_info;
        2283         [ +  + ]:     101972 :             if (exc_info->exc_value != NULL) {
        2284                 :      56209 :                 prev_exc = exc_info->exc_value;
        2285                 :            :             }
        2286                 :            :             else {
        2287                 :      45763 :                 prev_exc = Py_NewRef(Py_None);
        2288                 :            :             }
        2289                 :            :             assert(PyExceptionInstance_Check(new_exc));
        2290                 :     101972 :             exc_info->exc_value = Py_NewRef(new_exc);
        2291                 :            :         }
        2292                 :            :
        2293                 :            :         inst(LOAD_ATTR_METHOD_WITH_VALUES, (unused/1, type_version/2, keys_version/2, descr/4, self -- res2 if (oparg & 1), res)) {
        2294                 :            :             /* Cached method object */
        2295                 :            :             assert(cframe.use_tracing == 0);
        2296                 :     894487 :             PyTypeObject *self_cls = Py_TYPE(self);
        2297                 :            :             assert(type_version != 0);
        2298         [ +  + ]:     894487 :             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
        2299                 :            :             assert(self_cls->tp_flags & Py_TPFLAGS_MANAGED_DICT);
        2300                 :     893214 :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(self);
        2301         [ -  + ]:     893214 :             DEOPT_IF(!_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
        2302                 :     893214 :             PyHeapTypeObject *self_heap_type = (PyHeapTypeObject *)self_cls;
        2303         [ +  + ]:     893214 :             DEOPT_IF(self_heap_type->ht_cached_keys->dk_version !=
        2304                 :            :                      keys_version, LOAD_ATTR);
        2305                 :            :             STAT_INC(LOAD_ATTR, hit);
        2306                 :            :             assert(descr != NULL);
        2307                 :     893123 :             res2 = Py_NewRef(descr);
        2308                 :            :             assert(_PyType_HasFeature(Py_TYPE(res2), Py_TPFLAGS_METHOD_DESCRIPTOR));
        2309         [ +  - ]:     893123 :             res = self;
        2310                 :            :             assert(oparg & 1);
        2311                 :            :         }
        2312                 :            :
        2313                 :            :         inst(LOAD_ATTR_METHOD_NO_DICT, (unused/1, type_version/2, unused/2, descr/4, self -- res2 if (oparg & 1), res)) {
        2314                 :            :             assert(cframe.use_tracing == 0);
        2315                 :    2507024 :             PyTypeObject *self_cls = Py_TYPE(self);
        2316         [ -  + ]:    2507024 :             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
        2317                 :            :             assert(self_cls->tp_dictoffset == 0);
        2318                 :            :             STAT_INC(LOAD_ATTR, hit);
        2319                 :            :             assert(descr != NULL);
        2320                 :            :             assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
        2321                 :    2507024 :             res2 = Py_NewRef(descr);
        2322         [ +  - ]:    2507024 :             res = self;
        2323                 :            :             assert(oparg & 1);
        2324                 :            :         }
        2325                 :            :
        2326                 :            :         inst(LOAD_ATTR_METHOD_LAZY_DICT, (unused/1, type_version/2, unused/2, descr/4, self -- res2 if (oparg & 1), res)) {
        2327                 :            :             assert(cframe.use_tracing == 0);
        2328                 :        919 :             PyTypeObject *self_cls = Py_TYPE(self);
        2329         [ +  + ]:        919 :             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
        2330                 :        770 :             Py_ssize_t dictoffset = self_cls->tp_dictoffset;
        2331                 :            :             assert(dictoffset > 0);
        2332                 :        770 :             PyObject *dict = *(PyObject **)((char *)self + dictoffset);
        2333                 :            :             /* This object has a __dict__, just not yet created */
        2334         [ -  + ]:        770 :             DEOPT_IF(dict != NULL, LOAD_ATTR);
        2335                 :            :             STAT_INC(LOAD_ATTR, hit);
        2336                 :            :             assert(descr != NULL);
        2337                 :            :             assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
        2338                 :        770 :             res2 = Py_NewRef(descr);
        2339         [ +  - ]:        770 :             res = self;
        2340                 :            :             assert(oparg & 1);
        2341                 :            :         }
        2342                 :            :
        2343                 :            :         inst(KW_NAMES, (--)) {
        2344                 :            :             assert(kwnames == NULL);
        2345                 :            :             assert(oparg < PyTuple_GET_SIZE(frame->f_code->co_consts));
        2346                 :     175409 :             kwnames = GETITEM(frame->f_code->co_consts, oparg);
        2347                 :            :         }
        2348                 :            :
        2349                 :            :         // Cache layout: counter/1, func_version/2, min_args/1
        2350                 :            :         // Neither CALL_INTRINSIC_1/2 nor CALL_FUNCTION_EX are members!
        2351                 :            :         family(call, INLINE_CACHE_ENTRIES_CALL) = {
        2352                 :            :             CALL,
        2353                 :            :             CALL_BOUND_METHOD_EXACT_ARGS,
        2354                 :            :             CALL_PY_EXACT_ARGS,
        2355                 :            :             CALL_PY_WITH_DEFAULTS,
        2356                 :            :             CALL_NO_KW_TYPE_1,
        2357                 :            :             CALL_NO_KW_STR_1,
        2358                 :            :             CALL_NO_KW_TUPLE_1,
        2359                 :            :             CALL_BUILTIN_CLASS,
        2360                 :            :             CALL_NO_KW_BUILTIN_O,
        2361                 :            :             CALL_NO_KW_BUILTIN_FAST,
        2362                 :            :             CALL_BUILTIN_FAST_WITH_KEYWORDS,
        2363                 :            :             CALL_NO_KW_LEN,
        2364                 :            :             CALL_NO_KW_ISINSTANCE,
        2365                 :            :             CALL_NO_KW_LIST_APPEND,
        2366                 :            :             CALL_NO_KW_METHOD_DESCRIPTOR_O,
        2367                 :            :             CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS,
        2368                 :            :             CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS,
        2369                 :            :             CALL_NO_KW_METHOD_DESCRIPTOR_FAST,
        2370                 :            :         };
        2371                 :            :
        2372                 :            :         // On entry, the stack is either
        2373                 :            :         //   [NULL, callable, arg1, arg2, ...]
        2374                 :            :         // or
        2375                 :            :         //   [method, self, arg1, arg2, ...]
        2376                 :            :         // (Some args may be keywords, see KW_NAMES, which sets 'kwnames'.)
        2377                 :            :         // On exit, the stack is [result].
        2378                 :            :         // When calling Python, inline the call using DISPATCH_INLINED().
        2379                 :            :         inst(CALL, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2380                 :    3688976 :             int is_meth = method != NULL;
        2381                 :    3688976 :             int total_args = oparg;
        2382         [ +  + ]:    3688976 :             if (is_meth) {
        2383                 :    1857459 :                 callable = method;
        2384                 :    1857459 :                 args--;
        2385                 :    1857459 :                 total_args++;
        2386                 :            :             }
        2387                 :            :             #if ENABLE_SPECIALIZATION
        2388                 :    3688976 :             _PyCallCache *cache = (_PyCallCache *)next_instr;
        2389         [ +  + ]:    3688976 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
        2390                 :            :                 assert(cframe.use_tracing == 0);
        2391                 :      21614 :                 next_instr--;
        2392                 :      21614 :                 _Py_Specialize_Call(callable, next_instr, total_args, kwnames);
        2393                 :      21614 :                 DISPATCH_SAME_OPARG();
        2394                 :            :             }
        2395                 :            :             STAT_INC(CALL, deferred);
        2396                 :    3667362 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
        2397                 :            :             #endif  /* ENABLE_SPECIALIZATION */
        2398   [ +  +  +  + ]:    3667362 :             if (!is_meth && Py_TYPE(callable) == &PyMethod_Type) {
        2399                 :     153357 :                 is_meth = 1;  // For consistenct; it's dead, though
        2400                 :     153357 :                 args--;
        2401                 :     153357 :                 total_args++;
        2402                 :     153357 :                 PyObject *self = ((PyMethodObject *)callable)->im_self;
        2403                 :     153357 :                 args[0] = Py_NewRef(self);
        2404                 :     153357 :                 method = ((PyMethodObject *)callable)->im_func;
        2405                 :     153357 :                 args[-1] = Py_NewRef(method);
        2406         [ +  + ]:     153357 :                 Py_DECREF(callable);
        2407                 :     153357 :                 callable = method;
        2408                 :            :             }
        2409         [ +  + ]:    3667362 :             int positional_args = total_args - KWNAMES_LEN();
        2410                 :            :             // Check if the call can be inlined or not
        2411         [ +  + ]:    3667362 :             if (Py_TYPE(callable) == &PyFunction_Type &&
        2412         [ +  - ]:     293906 :                 tstate->interp->eval_frame == NULL &&
        2413         [ +  - ]:     293906 :                 ((PyFunctionObject *)callable)->vectorcall == _PyFunction_Vectorcall)
        2414                 :            :             {
        2415                 :     293906 :                 int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable))->co_flags;
        2416         [ -  + ]:     293906 :                 PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable));
        2417                 :     293906 :                 _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
        2418                 :            :                     tstate, (PyFunctionObject *)callable, locals,
        2419                 :            :                     args, positional_args, kwnames
        2420                 :            :                 );
        2421                 :     293906 :                 kwnames = NULL;
        2422                 :            :                 // Manipulate stack directly since we leave using DISPATCH_INLINED().
        2423                 :     293906 :                 STACK_SHRINK(oparg + 2);
        2424                 :            :                 // The frame has stolen all the arguments from the stack,
        2425                 :            :                 // so there is no need to clean them up.
        2426         [ -  + ]:     293906 :                 if (new_frame == NULL) {
        2427                 :          0 :                     goto error;
        2428                 :            :                 }
        2429                 :     293906 :                 JUMPBY(INLINE_CACHE_ENTRIES_CALL);
        2430                 :     293906 :                 DISPATCH_INLINED(new_frame);
        2431                 :            :             }
        2432                 :            :             /* Callable is not a normal Python function */
        2433         [ -  + ]:    3373456 :             if (cframe.use_tracing) {
        2434                 :          0 :                 res = trace_call_function(
        2435                 :            :                     tstate, callable, args,
        2436                 :            :                     positional_args, kwnames);
        2437                 :            :             }
        2438                 :            :             else {
        2439                 :    3373456 :                 res = PyObject_Vectorcall(
        2440                 :            :                     callable, args,
        2441                 :            :                     positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
        2442                 :            :                     kwnames);
        2443                 :            :             }
        2444                 :    3373456 :             kwnames = NULL;
        2445                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2446         [ +  + ]:    3373456 :             Py_DECREF(callable);
        2447         [ +  + ]:    8655777 :             for (int i = 0; i < total_args; i++) {
        2448         [ +  + ]:    5282321 :                 Py_DECREF(args[i]);
        2449                 :            :             }
        2450         [ +  + ]:    3373456 :             ERROR_IF(res == NULL, error);
        2451                 :            :             CHECK_EVAL_BREAKER();
        2452                 :            :         }
        2453                 :            :
        2454                 :            :         // Start out with [NULL, bound_method, arg1, arg2, ...]
        2455                 :            :         // Transform to [callable, self, arg1, arg2, ...]
        2456                 :            :         // Then fall through to CALL_PY_EXACT_ARGS
        2457                 :            :         inst(CALL_BOUND_METHOD_EXACT_ARGS, (unused/1, unused/2, unused/1, method, callable, unused[oparg] -- unused)) {
        2458         [ +  + ]:     671078 :             DEOPT_IF(method != NULL, CALL);
        2459         [ -  + ]:     569357 :             DEOPT_IF(Py_TYPE(callable) != &PyMethod_Type, CALL);
        2460                 :            :             STAT_INC(CALL, hit);
        2461                 :     569357 :             PyObject *self = ((PyMethodObject *)callable)->im_self;
        2462                 :     569357 :             PEEK(oparg + 1) = Py_NewRef(self);  // callable
        2463                 :     569357 :             PyObject *meth = ((PyMethodObject *)callable)->im_func;
        2464                 :     569357 :             PEEK(oparg + 2) = Py_NewRef(meth);  // method
        2465         [ +  + ]:     569357 :             Py_DECREF(callable);
        2466                 :     569357 :             GO_TO_INSTRUCTION(CALL_PY_EXACT_ARGS);
        2467                 :            :         }
        2468                 :            :
        2469                 :            :         inst(CALL_PY_EXACT_ARGS, (unused/1, func_version/2, unused/1, method, callable, args[oparg] -- unused)) {
        2470                 :            :             assert(kwnames == NULL);
        2471         [ -  + ]:    1931482 :             DEOPT_IF(tstate->interp->eval_frame, CALL);
        2472                 :    1931482 :             int is_meth = method != NULL;
        2473                 :    1931482 :             int argcount = oparg;
        2474         [ +  + ]:    1931482 :             if (is_meth) {
        2475                 :    1316183 :                 callable = method;
        2476                 :    1316183 :                 args--;
        2477                 :    1316183 :                 argcount++;
        2478                 :            :             }
        2479         [ +  + ]:    1931482 :             DEOPT_IF(!PyFunction_Check(callable), CALL);
        2480                 :    1930934 :             PyFunctionObject *func = (PyFunctionObject *)callable;
        2481         [ +  + ]:    1930934 :             DEOPT_IF(func->func_version != func_version, CALL);
        2482                 :    1917451 :             PyCodeObject *code = (PyCodeObject *)func->func_code;
        2483         [ -  + ]:    1917451 :             DEOPT_IF(code->co_argcount != argcount, CALL);
        2484         [ -  + ]:    1917451 :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
        2485                 :            :             STAT_INC(CALL, hit);
        2486                 :    1917451 :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, func, argcount);
        2487         [ +  + ]:    6127110 :             for (int i = 0; i < argcount; i++) {
        2488                 :    4209659 :                 new_frame->localsplus[i] = args[i];
        2489                 :            :             }
        2490                 :            :             // Manipulate stack directly since we leave using DISPATCH_INLINED().
        2491                 :    1917451 :             STACK_SHRINK(oparg + 2);
        2492                 :    1917451 :             JUMPBY(INLINE_CACHE_ENTRIES_CALL);
        2493                 :    1917451 :             DISPATCH_INLINED(new_frame);
        2494                 :            :         }
        2495                 :            :
        2496                 :            :         inst(CALL_PY_WITH_DEFAULTS, (unused/1, func_version/2, min_args/1, method, callable, args[oparg] -- unused)) {
        2497                 :            :             assert(kwnames == NULL);
        2498         [ -  + ]:     222502 :             DEOPT_IF(tstate->interp->eval_frame, CALL);
        2499                 :     222502 :             int is_meth = method != NULL;
        2500                 :     222502 :             int argcount = oparg;
        2501         [ +  + ]:     222502 :             if (is_meth) {
        2502                 :     214989 :                 callable = method;
        2503                 :     214989 :                 args--;
        2504                 :     214989 :                 argcount++;
        2505                 :            :             }
        2506         [ -  + ]:     222502 :             DEOPT_IF(!PyFunction_Check(callable), CALL);
        2507                 :     222502 :             PyFunctionObject *func = (PyFunctionObject *)callable;
        2508         [ -  + ]:     222502 :             DEOPT_IF(func->func_version != func_version, CALL);
        2509                 :     222502 :             PyCodeObject *code = (PyCodeObject *)func->func_code;
        2510         [ -  + ]:     222502 :             DEOPT_IF(argcount > code->co_argcount, CALL);
        2511         [ -  + ]:     222502 :             DEOPT_IF(argcount < min_args, CALL);
        2512         [ -  + ]:     222502 :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
        2513                 :            :             STAT_INC(CALL, hit);
        2514                 :     222502 :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, func, code->co_argcount);
        2515         [ +  + ]:     856571 :             for (int i = 0; i < argcount; i++) {
        2516                 :     634069 :                 new_frame->localsplus[i] = args[i];
        2517                 :            :             }
        2518         [ +  + ]:     445406 :             for (int i = argcount; i < code->co_argcount; i++) {
        2519                 :     222904 :                 PyObject *def = PyTuple_GET_ITEM(func->func_defaults, i - min_args);
        2520                 :     222904 :                 new_frame->localsplus[i] = Py_NewRef(def);
        2521                 :            :             }
        2522                 :            :             // Manipulate stack and cache directly since we leave using DISPATCH_INLINED().
        2523                 :     222502 :             STACK_SHRINK(oparg + 2);
        2524                 :     222502 :             JUMPBY(INLINE_CACHE_ENTRIES_CALL);
        2525                 :     222502 :             DISPATCH_INLINED(new_frame);
        2526                 :            :         }
        2527                 :            :
        2528                 :            :         inst(CALL_NO_KW_TYPE_1, (unused/1, unused/2, unused/1, null, callable, args[oparg] -- res)) {
        2529                 :            :             assert(kwnames == NULL);
        2530                 :            :             assert(cframe.use_tracing == 0);
        2531                 :            :             assert(oparg == 1);
        2532         [ -  + ]:     597184 :             DEOPT_IF(null != NULL, CALL);
        2533                 :     597184 :             PyObject *obj = args[0];
        2534         [ -  + ]:     597184 :             DEOPT_IF(callable != (PyObject *)&PyType_Type, CALL);
        2535                 :            :             STAT_INC(CALL, hit);
        2536                 :     597184 :             res = Py_NewRef(Py_TYPE(obj));
        2537         [ -  + ]:     597184 :             Py_DECREF(obj);
        2538         [ -  + ]:     597184 :             Py_DECREF(&PyType_Type);  // I.e., callable
        2539                 :            :         }
        2540                 :            :
        2541                 :            :         inst(CALL_NO_KW_STR_1, (unused/1, unused/2, unused/1, null, callable, args[oparg] -- res)) {
        2542                 :            :             assert(kwnames == NULL);
        2543                 :            :             assert(cframe.use_tracing == 0);
        2544                 :            :             assert(oparg == 1);
        2545         [ -  + ]:     262860 :             DEOPT_IF(null != NULL, CALL);
        2546         [ -  + ]:     262860 :             DEOPT_IF(callable != (PyObject *)&PyUnicode_Type, CALL);
        2547                 :            :             STAT_INC(CALL, hit);
        2548                 :     262860 :             PyObject *arg = args[0];
        2549                 :     262860 :             res = PyObject_Str(arg);
        2550         [ -  + ]:     262860 :             Py_DECREF(arg);
        2551         [ -  + ]:     262860 :             Py_DECREF(&PyUnicode_Type);  // I.e., callable
        2552         [ -  + ]:     262860 :             ERROR_IF(res == NULL, error);
        2553                 :            :             CHECK_EVAL_BREAKER();
        2554                 :            :         }
        2555                 :            :
        2556                 :            :         inst(CALL_NO_KW_TUPLE_1, (unused/1, unused/2, unused/1, null, callable, args[oparg] -- res)) {
        2557                 :            :             assert(kwnames == NULL);
        2558                 :            :             assert(oparg == 1);
        2559         [ -  + ]:      10082 :             DEOPT_IF(null != NULL, CALL);
        2560         [ -  + ]:      10082 :             DEOPT_IF(callable != (PyObject *)&PyTuple_Type, CALL);
        2561                 :            :             STAT_INC(CALL, hit);
        2562                 :      10082 :             PyObject *arg = args[0];
        2563                 :      10082 :             res = PySequence_Tuple(arg);
        2564         [ +  + ]:      10082 :             Py_DECREF(arg);
        2565         [ -  + ]:      10082 :             Py_DECREF(&PyTuple_Type);  // I.e., tuple
        2566         [ -  + ]:      10082 :             ERROR_IF(res == NULL, error);
        2567                 :            :             CHECK_EVAL_BREAKER();
        2568                 :            :         }
        2569                 :            :
        2570                 :            :         inst(CALL_BUILTIN_CLASS, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2571                 :     358271 :             int is_meth = method != NULL;
        2572                 :     358271 :             int total_args = oparg;
        2573         [ -  + ]:     358271 :             if (is_meth) {
        2574                 :          0 :                 callable = method;
        2575                 :          0 :                 args--;
        2576                 :          0 :                 total_args++;
        2577                 :            :             }
        2578         [ +  + ]:     358271 :             int kwnames_len = KWNAMES_LEN();
        2579         [ -  + ]:     358271 :             DEOPT_IF(!PyType_Check(callable), CALL);
        2580                 :     358271 :             PyTypeObject *tp = (PyTypeObject *)callable;
        2581         [ -  + ]:     358271 :             DEOPT_IF(tp->tp_vectorcall == NULL, CALL);
        2582                 :            :             STAT_INC(CALL, hit);
        2583                 :     358271 :             res = tp->tp_vectorcall((PyObject *)tp, args,
        2584                 :     358271 :                                     total_args - kwnames_len, kwnames);
        2585                 :     358271 :             kwnames = NULL;
        2586                 :            :             /* Free the arguments. */
        2587         [ +  + ]:     994967 :             for (int i = 0; i < total_args; i++) {
        2588         [ +  + ]:     636696 :                 Py_DECREF(args[i]);
        2589                 :            :             }
        2590         [ -  + ]:     358271 :             Py_DECREF(tp);
        2591         [ -  + ]:     358271 :             ERROR_IF(res == NULL, error);
        2592                 :            :             CHECK_EVAL_BREAKER();
        2593                 :            :         }
        2594                 :            :
        2595                 :            :         inst(CALL_NO_KW_BUILTIN_O, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2596                 :            :             assert(cframe.use_tracing == 0);
        2597                 :            :             /* Builtin METH_O functions */
        2598                 :            :             assert(kwnames == NULL);
        2599                 :    1570932 :             int is_meth = method != NULL;
        2600                 :    1570932 :             int total_args = oparg;
        2601         [ -  + ]:    1570932 :             if (is_meth) {
        2602                 :          0 :                 callable = method;
        2603                 :          0 :                 args--;
        2604                 :          0 :                 total_args++;
        2605                 :            :             }
        2606         [ -  + ]:    1570932 :             DEOPT_IF(total_args != 1, CALL);
        2607         [ -  + ]:    1570932 :             DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
        2608         [ +  + ]:    1570932 :             DEOPT_IF(PyCFunction_GET_FLAGS(callable) != METH_O, CALL);
        2609                 :            :             STAT_INC(CALL, hit);
        2610                 :    1570384 :             PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
        2611                 :            :             // This is slower but CPython promises to check all non-vectorcall
        2612                 :            :             // function calls.
        2613         [ -  + ]:    1570384 :             if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
        2614                 :          0 :                 goto error;
        2615                 :            :             }
        2616                 :    1570384 :             PyObject *arg = args[0];
        2617                 :    1570384 :             res = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable), arg);
        2618                 :    1570384 :             _Py_LeaveRecursiveCallTstate(tstate);
        2619                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2620                 :            :
        2621         [ +  + ]:    1570384 :             Py_DECREF(arg);
        2622         [ +  + ]:    1570384 :             Py_DECREF(callable);
        2623         [ +  + ]:    1570384 :             ERROR_IF(res == NULL, error);
        2624                 :            :             CHECK_EVAL_BREAKER();
        2625                 :            :         }
        2626                 :            :
        2627                 :            :         inst(CALL_NO_KW_BUILTIN_FAST, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2628                 :            :             assert(cframe.use_tracing == 0);
        2629                 :            :             /* Builtin METH_FASTCALL functions, without keywords */
        2630                 :            :             assert(kwnames == NULL);
        2631                 :    1210517 :             int is_meth = method != NULL;
        2632                 :    1210517 :             int total_args = oparg;
        2633         [ -  + ]:    1210517 :             if (is_meth) {
        2634                 :          0 :                 callable = method;
        2635                 :          0 :                 args--;
        2636                 :          0 :                 total_args++;
        2637                 :            :             }
        2638         [ -  + ]:    1210517 :             DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
        2639         [ +  + ]:    1210517 :             DEOPT_IF(PyCFunction_GET_FLAGS(callable) != METH_FASTCALL, CALL);
        2640                 :            :             STAT_INC(CALL, hit);
        2641                 :    1210370 :             PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
        2642                 :            :             /* res = func(self, args, nargs) */
        2643                 :    1210370 :             res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
        2644                 :            :                 PyCFunction_GET_SELF(callable),
        2645                 :            :                 args,
        2646                 :            :                 total_args);
        2647                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2648                 :            :
        2649                 :            :             /* Free the arguments. */
        2650         [ +  + ]:    3546933 :             for (int i = 0; i < total_args; i++) {
        2651         [ +  + ]:    2336563 :                 Py_DECREF(args[i]);
        2652                 :            :             }
        2653         [ +  + ]:    1210370 :             Py_DECREF(callable);
        2654         [ +  + ]:    1210370 :             ERROR_IF(res == NULL, error);
        2655                 :            :                 /* Not deopting because this doesn't mean our optimization was
        2656                 :            :                    wrong. `res` can be NULL for valid reasons. Eg. getattr(x,
        2657                 :            :                    'invalid'). In those cases an exception is set, so we must
        2658                 :            :                    handle it.
        2659                 :            :                 */
        2660                 :            :             CHECK_EVAL_BREAKER();
        2661                 :            :         }
        2662                 :            :
        2663                 :            :         inst(CALL_BUILTIN_FAST_WITH_KEYWORDS, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2664                 :            :             assert(cframe.use_tracing == 0);
        2665                 :            :             /* Builtin METH_FASTCALL | METH_KEYWORDS functions */
        2666                 :      12250 :             int is_meth = method != NULL;
        2667                 :      12250 :             int total_args = oparg;
        2668         [ -  + ]:      12250 :             if (is_meth) {
        2669                 :          0 :                 callable = method;
        2670                 :          0 :                 args--;
        2671                 :          0 :                 total_args++;
        2672                 :            :             }
        2673         [ -  + ]:      12250 :             DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
        2674         [ +  + ]:      12250 :             DEOPT_IF(PyCFunction_GET_FLAGS(callable) !=
        2675                 :            :                 (METH_FASTCALL | METH_KEYWORDS), CALL);
        2676                 :            :             STAT_INC(CALL, hit);
        2677                 :            :             /* res = func(self, args, nargs, kwnames) */
        2678                 :            :             _PyCFunctionFastWithKeywords cfunc =
        2679                 :            :                 (_PyCFunctionFastWithKeywords)(void(*)(void))
        2680                 :      11111 :                 PyCFunction_GET_FUNCTION(callable);
        2681                 :      11111 :             res = cfunc(
        2682                 :            :                 PyCFunction_GET_SELF(callable),
        2683                 :            :                 args,
        2684         [ +  + ]:      11111 :                 total_args - KWNAMES_LEN(),
        2685                 :            :                 kwnames
        2686                 :            :             );
        2687                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2688                 :      11111 :             kwnames = NULL;
        2689                 :            :
        2690                 :            :             /* Free the arguments. */
        2691         [ +  + ]:      24415 :             for (int i = 0; i < total_args; i++) {
        2692         [ +  + ]:      13304 :                 Py_DECREF(args[i]);
        2693                 :            :             }
        2694         [ -  + ]:      11111 :             Py_DECREF(callable);
        2695         [ +  + ]:      11111 :             ERROR_IF(res == NULL, error);
        2696                 :            :             CHECK_EVAL_BREAKER();
        2697                 :            :         }
        2698                 :            :
        2699                 :            :         inst(CALL_NO_KW_LEN, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2700                 :            :             assert(cframe.use_tracing == 0);
        2701                 :            :             assert(kwnames == NULL);
        2702                 :            :             /* len(o) */
        2703                 :      44344 :             int is_meth = method != NULL;
        2704                 :      44344 :             int total_args = oparg;
        2705         [ -  + ]:      44344 :             if (is_meth) {
        2706                 :          0 :                 callable = method;
        2707                 :          0 :                 args--;
        2708                 :          0 :                 total_args++;
        2709                 :            :             }
        2710         [ -  + ]:      44344 :             DEOPT_IF(total_args != 1, CALL);
        2711                 :      44344 :             PyInterpreterState *interp = _PyInterpreterState_GET();
        2712         [ -  + ]:      44344 :             DEOPT_IF(callable != interp->callable_cache.len, CALL);
        2713                 :            :             STAT_INC(CALL, hit);
        2714                 :      44344 :             PyObject *arg = args[0];
        2715                 :      44344 :             Py_ssize_t len_i = PyObject_Length(arg);
        2716         [ -  + ]:      44344 :             if (len_i < 0) {
        2717                 :          0 :                 goto error;
        2718                 :            :             }
        2719                 :      44344 :             res = PyLong_FromSsize_t(len_i);
        2720                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2721                 :            :
        2722         [ -  + ]:      44344 :             Py_DECREF(callable);
        2723         [ +  + ]:      44344 :             Py_DECREF(arg);
        2724         [ -  + ]:      44344 :             ERROR_IF(res == NULL, error);
        2725                 :            :         }
        2726                 :            :
        2727                 :            :         inst(CALL_NO_KW_ISINSTANCE, (unused/1, unused/2, unused/1, method, callable, args[oparg] -- res)) {
        2728                 :            :             assert(cframe.use_tracing == 0);
        2729                 :            :             assert(kwnames == NULL);
        2730                 :            :             /* isinstance(o, o2) */
        2731                 :     588295 :             int is_meth = method != NULL;
        2732                 :     588295 :             int total_args = oparg;
        2733         [ -  + ]:     588295 :             if (is_meth) {
        2734                 :          0 :                 callable = method;
        2735                 :          0 :                 args--;
        2736                 :          0 :                 total_args++;
        2737                 :            :             }
        2738         [ -  + ]:     588295 :             DEOPT_IF(total_args != 2, CALL);
        2739                 :     588295 :             PyInterpreterState *interp = _PyInterpreterState_GET();
        2740         [ -  + ]:     588295 :             DEOPT_IF(callable != interp->callable_cache.isinstance, CALL);
        2741                 :            :             STAT_INC(CALL, hit);
        2742                 :     588295 :             PyObject *cls = args[1];
        2743                 :     588295 :             PyObject *inst = args[0];
        2744                 :     588295 :             int retval = PyObject_IsInstance(inst, cls);
        2745         [ -  + ]:     588295 :             if (retval < 0) {
        2746                 :          0 :                 goto error;
        2747                 :            :             }
        2748                 :     588295 :             res = PyBool_FromLong(retval);
        2749                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2750                 :            :
        2751         [ -  + ]:     588295 :             Py_DECREF(inst);
        2752         [ +  + ]:     588295 :             Py_DECREF(cls);
        2753         [ -  + ]:     588295 :             Py_DECREF(callable);
        2754         [ -  + ]:     588295 :             ERROR_IF(res == NULL, error);
        2755                 :            :         }
        2756                 :            :
        2757                 :            :         // This is secretly a super-instruction
        2758                 :            :         inst(CALL_NO_KW_LIST_APPEND, (unused/1, unused/2, unused/1, method, self, args[oparg] -- unused)) {
        2759                 :            :             assert(cframe.use_tracing == 0);
        2760                 :            :             assert(kwnames == NULL);
        2761                 :            :             assert(oparg == 1);
        2762                 :            :             assert(method != NULL);
        2763                 :     498519 :             PyInterpreterState *interp = _PyInterpreterState_GET();
        2764         [ -  + ]:     498519 :             DEOPT_IF(method != interp->callable_cache.list_append, CALL);
        2765         [ -  + ]:     498519 :             DEOPT_IF(!PyList_Check(self), CALL);
        2766                 :            :             STAT_INC(CALL, hit);
        2767         [ -  + ]:     498519 :             if (_PyList_AppendTakeRef((PyListObject *)self, args[0]) < 0) {
        2768                 :          0 :                 goto pop_1_error;  // Since arg is DECREF'ed already
        2769                 :            :             }
        2770         [ -  + ]:     498519 :             Py_DECREF(self);
        2771         [ -  + ]:     498519 :             Py_DECREF(method);
        2772                 :     498519 :             STACK_SHRINK(3);
        2773                 :            :             // CALL + POP_TOP
        2774                 :     498519 :             JUMPBY(INLINE_CACHE_ENTRIES_CALL + 1);
        2775                 :            :             assert(next_instr[-1].op.code == POP_TOP);
        2776                 :     498519 :             DISPATCH();
        2777                 :            :         }
        2778                 :            :
        2779                 :            :         inst(CALL_NO_KW_METHOD_DESCRIPTOR_O, (unused/1, unused/2, unused/1, method, unused, args[oparg] -- res)) {
        2780                 :            :             assert(kwnames == NULL);
        2781                 :     237456 :             int is_meth = method != NULL;
        2782                 :     237456 :             int total_args = oparg;
        2783         [ +  - ]:     237456 :             if (is_meth) {
        2784                 :     237456 :                 args--;
        2785                 :     237456 :                 total_args++;
        2786                 :            :             }
        2787                 :     237456 :             PyMethodDescrObject *callable =
        2788                 :     237456 :                 (PyMethodDescrObject *)PEEK(total_args + 1);
        2789         [ -  + ]:     237456 :             DEOPT_IF(total_args != 2, CALL);
        2790         [ -  + ]:     237456 :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
        2791                 :     237456 :             PyMethodDef *meth = callable->d_method;
        2792         [ -  + ]:     237456 :             DEOPT_IF(meth->ml_flags != METH_O, CALL);
        2793                 :     237456 :             PyObject *arg = args[1];
        2794                 :     237456 :             PyObject *self = args[0];
        2795         [ +  + ]:     237456 :             DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
        2796                 :            :             STAT_INC(CALL, hit);
        2797                 :      87921 :             PyCFunction cfunc = meth->ml_meth;
        2798                 :            :             // This is slower but CPython promises to check all non-vectorcall
        2799                 :            :             // function calls.
        2800         [ -  + ]:      87921 :             if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
        2801                 :          0 :                 goto error;
        2802                 :            :             }
        2803                 :      87921 :             res = _PyCFunction_TrampolineCall(cfunc, self, arg);
        2804                 :      87921 :             _Py_LeaveRecursiveCallTstate(tstate);
        2805                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2806         [ -  + ]:      87921 :             Py_DECREF(self);
        2807         [ +  + ]:      87921 :             Py_DECREF(arg);
        2808         [ -  + ]:      87921 :             Py_DECREF(callable);
        2809         [ +  + ]:      87921 :             ERROR_IF(res == NULL, error);
        2810                 :            :             CHECK_EVAL_BREAKER();
        2811                 :            :         }
        2812                 :            :
        2813                 :            :         inst(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (unused/1, unused/2, unused/1, method, unused, args[oparg] -- res)) {
        2814                 :      20601 :             int is_meth = method != NULL;
        2815                 :      20601 :             int total_args = oparg;
        2816         [ +  - ]:      20601 :             if (is_meth) {
        2817                 :      20601 :                 args--;
        2818                 :      20601 :                 total_args++;
        2819                 :            :             }
        2820                 :      20601 :             PyMethodDescrObject *callable =
        2821                 :      20601 :                 (PyMethodDescrObject *)PEEK(total_args + 1);
        2822         [ -  + ]:      20601 :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
        2823                 :      20601 :             PyMethodDef *meth = callable->d_method;
        2824         [ -  + ]:      20601 :             DEOPT_IF(meth->ml_flags != (METH_FASTCALL|METH_KEYWORDS), CALL);
        2825                 :      20601 :             PyTypeObject *d_type = callable->d_common.d_type;
        2826                 :      20601 :             PyObject *self = args[0];
        2827         [ -  + ]:      20601 :             DEOPT_IF(!Py_IS_TYPE(self, d_type), CALL);
        2828                 :            :             STAT_INC(CALL, hit);
        2829                 :      20601 :             int nargs = total_args - 1;
        2830                 :      20601 :             _PyCFunctionFastWithKeywords cfunc =
        2831                 :            :                 (_PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
        2832         [ -  + ]:      20601 :             res = cfunc(self, args + 1, nargs - KWNAMES_LEN(), kwnames);
        2833                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2834                 :      20601 :             kwnames = NULL;
        2835                 :            :
        2836                 :            :             /* Free the arguments. */
        2837         [ +  + ]:      56413 :             for (int i = 0; i < total_args; i++) {
        2838         [ +  + ]:      35812 :                 Py_DECREF(args[i]);
        2839                 :            :             }
        2840         [ -  + ]:      20601 :             Py_DECREF(callable);
        2841         [ -  + ]:      20601 :             ERROR_IF(res == NULL, error);
        2842                 :            :             CHECK_EVAL_BREAKER();
        2843                 :            :         }
        2844                 :            :
        2845                 :            :         inst(CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS, (unused/1, unused/2, unused/1, method, unused, args[oparg] -- res)) {
        2846                 :            :             assert(kwnames == NULL);
        2847                 :            :             assert(oparg == 0 || oparg == 1);
        2848                 :     298114 :             int is_meth = method != NULL;
        2849                 :     298114 :             int total_args = oparg;
        2850         [ +  + ]:     298114 :             if (is_meth) {
        2851                 :     298058 :                 args--;
        2852                 :     298058 :                 total_args++;
        2853                 :            :             }
        2854         [ -  + ]:     298114 :             DEOPT_IF(total_args != 1, CALL);
        2855                 :     298114 :             PyMethodDescrObject *callable = (PyMethodDescrObject *)SECOND();
        2856         [ -  + ]:     298114 :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
        2857                 :     298114 :             PyMethodDef *meth = callable->d_method;
        2858                 :     298114 :             PyObject *self = args[0];
        2859         [ +  + ]:     298114 :             DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
        2860         [ -  + ]:     296088 :             DEOPT_IF(meth->ml_flags != METH_NOARGS, CALL);
        2861                 :            :             STAT_INC(CALL, hit);
        2862                 :     296088 :             PyCFunction cfunc = meth->ml_meth;
        2863                 :            :             // This is slower but CPython promises to check all non-vectorcall
        2864                 :            :             // function calls.
        2865         [ -  + ]:     296088 :             if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
        2866                 :          0 :                 goto error;
        2867                 :            :             }
        2868                 :     296088 :             res = _PyCFunction_TrampolineCall(cfunc, self, NULL);
        2869                 :     296088 :             _Py_LeaveRecursiveCallTstate(tstate);
        2870                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2871         [ +  + ]:     296088 :             Py_DECREF(self);
        2872         [ -  + ]:     296088 :             Py_DECREF(callable);
        2873         [ +  + ]:     296088 :             ERROR_IF(res == NULL, error);
        2874                 :            :             CHECK_EVAL_BREAKER();
        2875                 :            :         }
        2876                 :            :
        2877                 :            :         inst(CALL_NO_KW_METHOD_DESCRIPTOR_FAST, (unused/1, unused/2, unused/1, method, unused, args[oparg] -- res)) {
        2878                 :            :             assert(kwnames == NULL);
        2879                 :     164246 :             int is_meth = method != NULL;
        2880                 :     164246 :             int total_args = oparg;
        2881         [ +  + ]:     164246 :             if (is_meth) {
        2882                 :     164190 :                 args--;
        2883                 :     164190 :                 total_args++;
        2884                 :            :             }
        2885                 :     164246 :             PyMethodDescrObject *callable =
        2886                 :     164246 :                 (PyMethodDescrObject *)PEEK(total_args + 1);
        2887                 :            :             /* Builtin METH_FASTCALL methods, without keywords */
        2888         [ -  + ]:     164246 :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
        2889                 :     164246 :             PyMethodDef *meth = callable->d_method;
        2890         [ -  + ]:     164246 :             DEOPT_IF(meth->ml_flags != METH_FASTCALL, CALL);
        2891                 :     164246 :             PyObject *self = args[0];
        2892         [ +  + ]:     164246 :             DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
        2893                 :            :             STAT_INC(CALL, hit);
        2894                 :     164029 :             _PyCFunctionFast cfunc =
        2895                 :            :                 (_PyCFunctionFast)(void(*)(void))meth->ml_meth;
        2896                 :     164029 :             int nargs = total_args - 1;
        2897                 :     164029 :             res = cfunc(self, args + 1, nargs);
        2898                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
        2899                 :            :             /* Clear the stack of the arguments. */
        2900         [ +  + ]:     491170 :             for (int i = 0; i < total_args; i++) {
        2901         [ +  + ]:     327141 :                 Py_DECREF(args[i]);
        2902                 :            :             }
        2903         [ -  + ]:     164029 :             Py_DECREF(callable);
        2904         [ +  + ]:     164029 :             ERROR_IF(res == NULL, error);
        2905                 :            :             CHECK_EVAL_BREAKER();
        2906                 :            :         }
        2907                 :            :
        2908                 :            :         inst(CALL_FUNCTION_EX, (unused, func, callargs, kwargs if (oparg & 1) -- result)) {
        2909                 :     103224 :             if (oparg & 1) {
        2910                 :            :                 // DICT_MERGE is called before this opcode if there are kwargs.
        2911                 :            :                 // It converts all dict subtypes in kwargs into regular dicts.
        2912                 :            :                 assert(PyDict_CheckExact(kwargs));
        2913                 :            :             }
        2914         [ +  + ]:     103224 :             if (!PyTuple_CheckExact(callargs)) {
        2915         [ -  + ]:        302 :                 if (check_args_iterable(tstate, func, callargs) < 0) {
        2916                 :          0 :                     goto error;
        2917                 :            :                 }
        2918                 :        302 :                 PyObject *tuple = PySequence_Tuple(callargs);
        2919         [ -  + ]:        302 :                 if (tuple == NULL) {
        2920                 :          0 :                     goto error;
        2921                 :            :                 }
        2922         [ +  + ]:        302 :                 Py_SETREF(callargs, tuple);
        2923                 :            :             }
        2924                 :            :             assert(PyTuple_CheckExact(callargs));
        2925                 :            :
        2926                 :     103224 :             result = do_call_core(tstate, func, callargs, kwargs, cframe.use_tracing);
        2927                 :            :             DECREF_INPUTS();
        2928                 :            :
        2929                 :            :             assert(PEEK(3 + (oparg & 1)) == NULL);
        2930         [ +  + ]:     103224 :             ERROR_IF(result == NULL, error);
        2931                 :            :             CHECK_EVAL_BREAKER();
        2932                 :            :         }
        2933                 :            :
        2934                 :            :         inst(MAKE_FUNCTION, (defaults    if (oparg & 0x01),
        2935                 :            :                              kwdefaults  if (oparg & 0x02),
        2936                 :            :                              annotations if (oparg & 0x04),
        2937                 :            :                              closure     if (oparg & 0x08),
        2938                 :            :                              codeobj -- func)) {
        2939                 :            :
        2940                 :            :             PyFunctionObject *func_obj = (PyFunctionObject *)
        2941                 :     197280 :                 PyFunction_New(codeobj, GLOBALS());
        2942                 :            :
        2943         [ -  + ]:     197280 :             Py_DECREF(codeobj);
        2944         [ -  + ]:     197280 :             if (func_obj == NULL) {
        2945                 :          0 :                 goto error;
        2946                 :            :             }
        2947                 :            :
        2948         [ +  + ]:     197280 :             if (oparg & 0x08) {
        2949                 :            :                 assert(PyTuple_CheckExact(closure));
        2950                 :      25355 :                 func_obj->func_closure = closure;
        2951                 :            :             }
        2952         [ +  + ]:     197280 :             if (oparg & 0x04) {
        2953                 :            :                 assert(PyTuple_CheckExact(annotations));
        2954                 :      18213 :                 func_obj->func_annotations = annotations;
        2955                 :            :             }
        2956         [ +  + ]:     197280 :             if (oparg & 0x02) {
        2957                 :            :                 assert(PyDict_CheckExact(kwdefaults));
        2958                 :        688 :                 func_obj->func_kwdefaults = kwdefaults;
        2959                 :            :             }
        2960         [ +  + ]:     197280 :             if (oparg & 0x01) {
        2961                 :            :                 assert(PyTuple_CheckExact(defaults));
        2962                 :       4932 :                 func_obj->func_defaults = defaults;
        2963                 :            :             }
        2964                 :            :
        2965                 :     197280 :             func_obj->func_version = ((PyCodeObject *)codeobj)->co_version;
        2966                 :     197280 :             func = (PyObject *)func_obj;
        2967                 :            :         }
        2968                 :            :
        2969                 :            :         inst(RETURN_GENERATOR, (--)) {
        2970                 :            :             assert(PyFunction_Check(frame->f_funcobj));
        2971                 :     122420 :             PyFunctionObject *func = (PyFunctionObject *)frame->f_funcobj;
        2972                 :     122420 :             PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
        2973         [ -  + ]:     122420 :             if (gen == NULL) {
        2974                 :          0 :                 goto error;
        2975                 :            :             }
        2976                 :            :             assert(EMPTY());
        2977                 :     122420 :             _PyFrame_SetStackPointer(frame, stack_pointer);
        2978                 :     122420 :             _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
        2979                 :     122420 :             _PyFrame_Copy(frame, gen_frame);
        2980                 :            :             assert(frame->frame_obj == NULL);
        2981                 :     122420 :             gen->gi_frame_state = FRAME_CREATED;
        2982                 :     122420 :             gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
        2983                 :     122420 :             _Py_LeaveRecursiveCallPy(tstate);
        2984                 :            :             assert(frame != &entry_frame);
        2985                 :     122420 :             _PyInterpreterFrame *prev = frame->previous;
        2986                 :     122420 :             _PyThreadState_PopFrame(tstate, frame);
        2987                 :     122420 :             frame = cframe.current_frame = prev;
        2988                 :     122420 :             _PyFrame_StackPush(frame, (PyObject *)gen);
        2989                 :     122420 :             goto resume_frame;
        2990                 :            :         }
        2991                 :            :
        2992                 :            :         inst(BUILD_SLICE, (start, stop, step if (oparg == 3) -- slice)) {
        2993                 :       1181 :             slice = PySlice_New(start, stop, step);
        2994                 :            :             DECREF_INPUTS();
        2995         [ -  + ]:       1181 :             ERROR_IF(slice == NULL, error);
        2996                 :            :         }
        2997                 :            :
        2998                 :            :         inst(FORMAT_VALUE, (value, fmt_spec if ((oparg & FVS_MASK) == FVS_HAVE_SPEC) -- result)) {
        2999                 :            :             /* Handles f-string value formatting. */
        3000                 :            :             PyObject *(*conv_fn)(PyObject *);
        3001                 :     362437 :             int which_conversion = oparg & FVC_MASK;
        3002                 :            :
        3003                 :            :             /* See if any conversion is specified. */
        3004   [ +  +  +  -  :     362437 :             switch (which_conversion) {
                          - ]
        3005                 :     358656 :             case FVC_NONE:  conv_fn = NULL;           break;
        3006                 :       2924 :             case FVC_STR:   conv_fn = PyObject_Str;   break;
        3007                 :        857 :             case FVC_REPR:  conv_fn = PyObject_Repr;  break;
        3008                 :          0 :             case FVC_ASCII: conv_fn = PyObject_ASCII; break;
        3009                 :          0 :             default:
        3010                 :          0 :                 _PyErr_Format(tstate, PyExc_SystemError,
        3011                 :            :                               "unexpected conversion flag %d",
        3012                 :            :                               which_conversion);
        3013                 :          0 :                 goto error;
        3014                 :            :             }
        3015                 :            :
        3016                 :            :             /* If there's a conversion function, call it and replace
        3017                 :            :                value with that result. Otherwise, just use value,
        3018                 :            :                without conversion. */
        3019         [ +  + ]:     362437 :             if (conv_fn != NULL) {
        3020                 :       3781 :                 result = conv_fn(value);
        3021         [ -  + ]:       3781 :                 Py_DECREF(value);
        3022         [ -  + ]:       3781 :                 if (result == NULL) {
        3023   [ #  #  #  # ]:          0 :                     Py_XDECREF(fmt_spec);
        3024                 :          0 :                     ERROR_IF(true, error);
        3025                 :            :                 }
        3026                 :       3781 :                 value = result;
        3027                 :            :             }
        3028                 :            :
        3029                 :            :             /* If value is a unicode object, and there's no fmt_spec,
        3030                 :            :                then we know the result of format(value) is value
        3031                 :            :                itself. In that case, skip calling format(). I plan to
        3032                 :            :                move this optimization in to PyObject_Format()
        3033                 :            :                itself. */
        3034   [ +  +  +  - ]:     362437 :             if (PyUnicode_CheckExact(value) && fmt_spec == NULL) {
        3035                 :            :                 /* Do nothing, just transfer ownership to result. */
        3036                 :      58397 :                 result = value;
        3037                 :            :             } else {
        3038                 :            :                 /* Actually call format(). */
        3039                 :     304040 :                 result = PyObject_Format(value, fmt_spec);
        3040                 :            :                 DECREF_INPUTS();
        3041         [ -  + ]:     304040 :                 ERROR_IF(result == NULL, error);
        3042                 :            :             }
        3043                 :            :         }
        3044                 :            :
        3045                 :            :         inst(COPY, (bottom, unused[oparg-1] -- bottom, unused[oparg-1], top)) {
        3046                 :            :             assert(oparg > 0);
        3047                 :     225025 :             top = Py_NewRef(bottom);
        3048                 :            :         }
        3049                 :            :
        3050                 :            :         inst(BINARY_OP, (unused/1, lhs, rhs -- res)) {
        3051                 :            :             #if ENABLE_SPECIALIZATION
        3052                 :    2224339 :             _PyBinaryOpCache *cache = (_PyBinaryOpCache *)next_instr;
        3053         [ +  + ]:    2224339 :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
        3054                 :            :                 assert(cframe.use_tracing == 0);
        3055                 :       3401 :                 next_instr--;
        3056                 :       3401 :                 _Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, &GETLOCAL(0));
        3057                 :       3401 :                 DISPATCH_SAME_OPARG();
        3058                 :            :             }
        3059                 :            :             STAT_INC(BINARY_OP, deferred);
        3060                 :    2220938 :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
        3061                 :            :             #endif  /* ENABLE_SPECIALIZATION */
        3062                 :            :             assert(0 <= oparg);
        3063                 :            :             assert((unsigned)oparg < Py_ARRAY_LENGTH(binary_ops));
        3064                 :            :             assert(binary_ops[oparg]);
        3065                 :    2220938 :             res = binary_ops[oparg](lhs, rhs);
        3066                 :            :             DECREF_INPUTS();
        3067         [ +  + ]:    2220938 :             ERROR_IF(res == NULL, error);
        3068                 :            :         }
        3069                 :            :
        3070                 :            :         inst(SWAP, (bottom, unused[oparg-2], top --
        3071                 :            :                     top, unused[oparg-2], bottom)) {
        3072                 :            :             assert(oparg >= 2);
        3073                 :            :         }
        3074                 :            :
        3075                 :            :         inst(EXTENDED_ARG, (--)) {
        3076                 :            :             assert(oparg);
        3077                 :            :             assert(cframe.use_tracing == 0);
        3078                 :      92853 :             opcode = next_instr->op.code;
        3079                 :      92853 :             oparg = oparg << 8 | next_instr->op.arg;
        3080                 :            :             PRE_DISPATCH_GOTO();
        3081                 :      92853 :             DISPATCH_GOTO();
        3082                 :            :         }
        3083                 :            :
        3084                 :            :         inst(CACHE, (--)) {
        3085                 :          0 :             Py_UNREACHABLE();
        3086                 :            :         }
        3087                 :            :
        3088                 :            :
        3089                 :            : // END BYTECODES //
        3090                 :            :
        3091                 :            :     }
        3092                 :            :  dispatch_opcode:
        3093                 :            :  error:
        3094                 :            :  exception_unwind:
        3095                 :            :  exit_unwind:
        3096                 :            :  handle_eval_breaker:
        3097                 :            :  resume_frame:
        3098                 :            :  resume_with_error:
        3099                 :            :  start_frame:
        3100                 :            :  unbound_local_error:
        3101                 :            :     ;
        3102                 :            : }
        3103                 :            :
        3104                 :            : // Future families go below this point //
        3105                 :            :
        3106                 :            : family(store_fast) = { STORE_FAST, STORE_FAST__LOAD_FAST, STORE_FAST__STORE_FAST };

Generated by: LCOV version 1.14