executor_cases.c.h

// This file is generated by Tools/cases_generator/generate_cases.py
// from:
//   Python/bytecodes.c
// Do not edit!

#ifdef TIER_ONE
    #error "This file is for Tier 2 only"
#endif
#define TIER_TWO 2

        case NOP: {
            break;
        }

        case RESUME_CHECK: {
#if defined(__EMSCRIPTEN__)
            DEOPT_IF(_Py_emscripten_signal_clock == 0, RESUME);
            _Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING;
#endif
            uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->interp->ceval.eval_breaker);
            uintptr_t version = _PyFrame_GetCode(frame)->_co_instrumentation_version;
            assert((version & _PY_EVAL_EVENTS_MASK) == 0);
            DEOPT_IF(eval_breaker != version, RESUME);
            break;
        }

        case LOAD_FAST_CHECK: {
            oparg = CURRENT_OPARG();
            PyObject *value;
            value = GETLOCAL(oparg);
            if (value == NULL) goto unbound_local_error_tier_two;
            Py_INCREF(value);
            STACK_GROW(1);
            stack_pointer[-1] = value;
            break;
        }

        case LOAD_FAST: {
            oparg = CURRENT_OPARG();
            PyObject *value;
            value = GETLOCAL(oparg);
            assert(value != NULL);
            Py_INCREF(value);
            STACK_GROW(1);
            stack_pointer[-1] = value;
            break;
        }

        case LOAD_FAST_AND_CLEAR: {
            oparg = CURRENT_OPARG();
            PyObject *value;
            value = GETLOCAL(oparg);
            // do not use SETLOCAL here, it decrefs the old value
            GETLOCAL(oparg) = NULL;
            STACK_GROW(1);
            stack_pointer[-1] = value;
            break;
        }

        case LOAD_CONST: {
            oparg = CURRENT_OPARG();
            PyObject *value;
            value = GETITEM(FRAME_CO_CONSTS, oparg);
            Py_INCREF(value);
            STACK_GROW(1);
            stack_pointer[-1] = value;
            break;
        }

        case STORE_FAST: {
            oparg = CURRENT_OPARG();
            PyObject *value;
            value = stack_pointer[-1];
            SETLOCAL(oparg, value);
            STACK_SHRINK(1);
            break;
        }

        case POP_TOP: {
            PyObject *value;
            value = stack_pointer[-1];
            Py_DECREF(value);
            STACK_SHRINK(1);
            break;
        }

        case PUSH_NULL: {
            PyObject *res;
            res = NULL;
            STACK_GROW(1);
            stack_pointer[-1] = res;
            break;
        }

        case END_SEND: {
            PyObject *value;
            PyObject *receiver;
            value = stack_pointer[-1];
            receiver = stack_pointer[-2];
            Py_DECREF(receiver);
            STACK_SHRINK(1);
            stack_pointer[-1] = value;
            break;
        }

        case UNARY_NEGATIVE: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            res = PyNumber_Negative(value);
            Py_DECREF(value);
            if (res == NULL) goto pop_1_error_tier_two;
            stack_pointer[-1] = res;
            break;
        }

        case UNARY_NOT: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            assert(PyBool_Check(value));
            res = Py_IsFalse(value) ? Py_True : Py_False;
            stack_pointer[-1] = res;
            break;
        }

        case _TO_BOOL: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            int err = PyObject_IsTrue(value);
            Py_DECREF(value);
            if (err < 0) goto pop_1_error_tier_two;
            res = err ? Py_True : Py_False;
            stack_pointer[-1] = res;
            break;
        }

        case TO_BOOL_BOOL: {
            PyObject *value;
            value = stack_pointer[-1];
            DEOPT_IF(!PyBool_Check(value), TO_BOOL);
            STAT_INC(TO_BOOL, hit);
            break;
        }

        case TO_BOOL_INT: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            DEOPT_IF(!PyLong_CheckExact(value), TO_BOOL);
            STAT_INC(TO_BOOL, hit);
            if (_PyLong_IsZero((PyLongObject *)value)) {
                assert(_Py_IsImmortal(value));
                res = Py_False;
            }
            else {
                Py_DECREF(value);
                res = Py_True;
            }
            stack_pointer[-1] = res;
            break;
        }

        case TO_BOOL_LIST: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            DEOPT_IF(!PyList_CheckExact(value), TO_BOOL);
            STAT_INC(TO_BOOL, hit);
            res = Py_SIZE(value) ? Py_True : Py_False;
            Py_DECREF(value);
            stack_pointer[-1] = res;
            break;
        }

        case TO_BOOL_NONE: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            // This one is a bit weird, because we expect *some* failures:
            DEOPT_IF(!Py_IsNone(value), TO_BOOL);
            STAT_INC(TO_BOOL, hit);
            res = Py_False;
            stack_pointer[-1] = res;
            break;
        }

        case TO_BOOL_STR: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            DEOPT_IF(!PyUnicode_CheckExact(value), TO_BOOL);
            STAT_INC(TO_BOOL, hit);
            if (value == &_Py_STR(empty)) {
                assert(_Py_IsImmortal(value));
                res = Py_False;
            }
            else {
                assert(Py_SIZE(value));
                Py_DECREF(value);
                res = Py_True;
            }
            stack_pointer[-1] = res;
            break;
        }

        case TO_BOOL_ALWAYS_TRUE: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            uint32_t version = (uint32_t)CURRENT_OPERAND();
            // This one is a bit weird, because we expect *some* failures:
            assert(version);
            DEOPT_IF(Py_TYPE(value)->tp_version_tag != version, TO_BOOL);
            STAT_INC(TO_BOOL, hit);
            Py_DECREF(value);
            res = Py_True;
            stack_pointer[-1] = res;
            break;
        }

        case UNARY_INVERT: {
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            res = PyNumber_Invert(value);
            Py_DECREF(value);
            if (res == NULL) goto pop_1_error_tier_two;
            stack_pointer[-1] = res;
            break;
        }

        case _GUARD_BOTH_INT: {
            PyObject *right;
            PyObject *left;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            DEOPT_IF(!PyLong_CheckExact(left), _GUARD_BOTH_INT);
            DEOPT_IF(!PyLong_CheckExact(right), _GUARD_BOTH_INT);
            break;
        }

        case _BINARY_OP_MULTIPLY_INT: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            res = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right);
            _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
            _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
            if (res == NULL) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _BINARY_OP_ADD_INT: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            res = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right);
            _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
            _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
            if (res == NULL) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _BINARY_OP_SUBTRACT_INT: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            res = _PyLong_Subtract((PyLongObject *)left, (PyLongObject *)right);
            _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
            _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
            if (res == NULL) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _GUARD_BOTH_FLOAT: {
            PyObject *right;
            PyObject *left;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            DEOPT_IF(!PyFloat_CheckExact(left), _GUARD_BOTH_FLOAT);
            DEOPT_IF(!PyFloat_CheckExact(right), _GUARD_BOTH_FLOAT);
            break;
        }

        case _BINARY_OP_MULTIPLY_FLOAT: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            double dres =
                ((PyFloatObject *)left)->ob_fval *
                ((PyFloatObject *)right)->ob_fval;
            DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dres, res);
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _BINARY_OP_ADD_FLOAT: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            double dres =
                ((PyFloatObject *)left)->ob_fval +
                ((PyFloatObject *)right)->ob_fval;
            DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dres, res);
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _BINARY_OP_SUBTRACT_FLOAT: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            double dres =
                ((PyFloatObject *)left)->ob_fval -
                ((PyFloatObject *)right)->ob_fval;
            DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dres, res);
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _GUARD_BOTH_UNICODE: {
            PyObject *right;
            PyObject *left;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            DEOPT_IF(!PyUnicode_CheckExact(left), _GUARD_BOTH_UNICODE);
            DEOPT_IF(!PyUnicode_CheckExact(right), _GUARD_BOTH_UNICODE);
            break;
        }

        case _BINARY_OP_ADD_UNICODE: {
            PyObject *right;
            PyObject *left;
            PyObject *res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            STAT_INC(BINARY_OP, hit);
            res = PyUnicode_Concat(left, right);
            _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
            _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
            if (res == NULL) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _BINARY_SUBSCR: {
            PyObject *sub;
            PyObject *container;
            PyObject *res;
            sub = stack_pointer[-1];
            container = stack_pointer[-2];
            res = PyObject_GetItem(container, sub);
            Py_DECREF(container);
            Py_DECREF(sub);
            if (res == NULL) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case BINARY_SLICE: {
            PyObject *stop;
            PyObject *start;
            PyObject *container;
            PyObject *res;
            stop = stack_pointer[-1];
            start = stack_pointer[-2];
            container = stack_pointer[-3];
            PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
            // Can't use ERROR_IF() here, because we haven't
            // DECREF'ed container yet, and we still own slice.
            if (slice == NULL) {
                res = NULL;
            }
            else {
                res = PyObject_GetItem(container, slice);
                Py_DECREF(slice);
            }
            Py_DECREF(container);
            if (res == NULL) goto pop_3_error_tier_two;
            STACK_SHRINK(2);
            stack_pointer[-1] = res;
            break;
        }

        case STORE_SLICE: {
            PyObject *stop;
            PyObject *start;
            PyObject *container;
            PyObject *v;
            stop = stack_pointer[-1];
            start = stack_pointer[-2];
            container = stack_pointer[-3];
            v = stack_pointer[-4];
            PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
            int err;
            if (slice == NULL) {
                err = 1;
            }
            else {
                err = PyObject_SetItem(container, slice, v);
                Py_DECREF(slice);
            }
            Py_DECREF(v);
            Py_DECREF(container);
            if (err) goto pop_4_error_tier_two;
            STACK_SHRINK(4);
            break;
        }

        case BINARY_SUBSCR_LIST_INT: {
            PyObject *sub;
            PyObject *list;
            PyObject *res;
            sub = stack_pointer[-1];
            list = stack_pointer[-2];
            DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
            DEOPT_IF(!PyList_CheckExact(list), BINARY_SUBSCR);

            // Deopt unless 0 <= sub < PyList_Size(list)
            DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), BINARY_SUBSCR);
            Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
            DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);
            STAT_INC(BINARY_SUBSCR, hit);
            res = PyList_GET_ITEM(list, index);
            assert(res != NULL);
            Py_INCREF(res);
            _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
            Py_DECREF(list);
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case BINARY_SUBSCR_STR_INT: {
            PyObject *sub;
            PyObject *str;
            PyObject *res;
            sub = stack_pointer[-1];
            str = stack_pointer[-2];
            DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
            DEOPT_IF(!PyUnicode_CheckExact(str), BINARY_SUBSCR);
            DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), BINARY_SUBSCR);
            Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
            DEOPT_IF(PyUnicode_GET_LENGTH(str) <= index, BINARY_SUBSCR);
            // Specialize for reading an ASCII character from any string:
            Py_UCS4 c = PyUnicode_READ_CHAR(str, index);
            DEOPT_IF(Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c, BINARY_SUBSCR);
            STAT_INC(BINARY_SUBSCR, hit);
            res = (PyObject*)&_Py_SINGLETON(strings).ascii[c];
            _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
            Py_DECREF(str);
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case BINARY_SUBSCR_TUPLE_INT: {
            PyObject *sub;
            PyObject *tuple;
            PyObject *res;
            sub = stack_pointer[-1];
            tuple = stack_pointer[-2];
            DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
            DEOPT_IF(!PyTuple_CheckExact(tuple), BINARY_SUBSCR);

            // Deopt unless 0 <= sub < PyTuple_Size(list)
            DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), BINARY_SUBSCR);
            Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
            DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);
            STAT_INC(BINARY_SUBSCR, hit);
            res = PyTuple_GET_ITEM(tuple, index);
            assert(res != NULL);
            Py_INCREF(res);
            _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
            Py_DECREF(tuple);
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case BINARY_SUBSCR_DICT: {
            PyObject *sub;
            PyObject *dict;
            PyObject *res;
            sub = stack_pointer[-1];
            dict = stack_pointer[-2];
            DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR);
            STAT_INC(BINARY_SUBSCR, hit);
            int rc = PyDict_GetItemRef(dict, sub, &res);
            if (rc == 0) {
                _PyErr_SetKeyError(sub);
            }
            Py_DECREF(dict);
            Py_DECREF(sub);
            if (rc <= 0) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case LIST_APPEND: {
            oparg = CURRENT_OPARG();
            PyObject *v;
            PyObject *list;
            v = stack_pointer[-1];
            list = stack_pointer[-2 - (oparg-1)];
            if (_PyList_AppendTakeRef((PyListObject *)list, v) < 0) goto pop_1_error_tier_two;
            STACK_SHRINK(1);
            break;
        }

        case SET_ADD: {
            oparg = CURRENT_OPARG();
            PyObject *v;
            PyObject *set;
            v = stack_pointer[-1];
            set = stack_pointer[-2 - (oparg-1)];
            int err = PySet_Add(set, v);
            Py_DECREF(v);
            if (err) goto pop_1_error_tier_two;
            STACK_SHRINK(1);
            break;
        }

        case _STORE_SUBSCR: {
            PyObject *sub;
            PyObject *container;
            PyObject *v;
            sub = stack_pointer[-1];
            container = stack_pointer[-2];
            v = stack_pointer[-3];
            /* container[sub] = v */
            int err = PyObject_SetItem(container, sub, v);
            Py_DECREF(v);
            Py_DECREF(container);
            Py_DECREF(sub);
            if (err) goto pop_3_error_tier_two;
            STACK_SHRINK(3);
            break;
        }

        case STORE_SUBSCR_LIST_INT: {
            PyObject *sub;
            PyObject *list;
            PyObject *value;
            sub = stack_pointer[-1];
            list = stack_pointer[-2];
            value = stack_pointer[-3];
            DEOPT_IF(!PyLong_CheckExact(sub), STORE_SUBSCR);
            DEOPT_IF(!PyList_CheckExact(list), STORE_SUBSCR);

            // Ensure nonnegative, zero-or-one-digit ints.
            DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), STORE_SUBSCR);
            Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
            // Ensure index < len(list)
            DEOPT_IF(index >= PyList_GET_SIZE(list), STORE_SUBSCR);
            STAT_INC(STORE_SUBSCR, hit);

            PyObject *old_value = PyList_GET_ITEM(list, index);
            PyList_SET_ITEM(list, index, value);
            assert(old_value != NULL);
            Py_DECREF(old_value);
            _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
            Py_DECREF(list);
            STACK_SHRINK(3);
            break;
        }

        case STORE_SUBSCR_DICT: {
            PyObject *sub;
            PyObject *dict;
            PyObject *value;
            sub = stack_pointer[-1];
            dict = stack_pointer[-2];
            value = stack_pointer[-3];
            DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR);
            STAT_INC(STORE_SUBSCR, hit);
            int err = _PyDict_SetItem_Take2((PyDictObject *)dict, sub, value);
            Py_DECREF(dict);
            if (err) goto pop_3_error_tier_two;
            STACK_SHRINK(3);
            break;
        }

        case DELETE_SUBSCR: {
            PyObject *sub;
            PyObject *container;
            sub = stack_pointer[-1];
            container = stack_pointer[-2];
            /* del container[sub] */
            int err = PyObject_DelItem(container, sub);
            Py_DECREF(container);
            Py_DECREF(sub);
            if (err) goto pop_2_error_tier_two;
            STACK_SHRINK(2);
            break;
        }

        case CALL_INTRINSIC_1: {
            oparg = CURRENT_OPARG();
            PyObject *value;
            PyObject *res;
            value = stack_pointer[-1];
            assert(oparg <= MAX_INTRINSIC_1);
            res = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, value);
            Py_DECREF(value);
            if (res == NULL) goto pop_1_error_tier_two;
            stack_pointer[-1] = res;
            break;
        }

        case CALL_INTRINSIC_2: {
            oparg = CURRENT_OPARG();
            PyObject *value1;
            PyObject *value2;
            PyObject *res;
            value1 = stack_pointer[-1];
            value2 = stack_pointer[-2];
            assert(oparg <= MAX_INTRINSIC_2);
            res = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
            Py_DECREF(value2);
            Py_DECREF(value1);
            if (res == NULL) goto pop_2_error_tier_two;
            STACK_SHRINK(1);
            stack_pointer[-1] = res;
            break;
        }

        case _POP_FRAME: {
            PyObject *retval;
            retval = stack_pointer[-1];
            STACK_SHRINK(1);
            assert(EMPTY());
            #if TIER_ONE
            assert(frame != &entry_frame);
            #endif
            STORE_SP();
            _Py_LeaveRecursiveCallPy(tstate);
            // GH-99729: We need to unlink the frame *before* clearing it:
            _PyInterpreterFrame *dying = frame;
            frame = tstate->current_frame = dying->previous;
            _PyEval_FrameClearAndPop(tstate, dying);
            _PyFrame_StackPush(frame, retval);
            LOAD_SP();
            LOAD_IP(frame->return_offset);
#if LLTRACE && TIER_ONE
            lltrace = maybe_lltrace_resume_frame(frame, &entry_frame, GLOBALS());
            if (lltrace < 0) {
                goto exit_unwind;
            }
#endif
            break;
        }

        case GET_AITER: {
            PyObject *obj;
            PyObject *iter;
            obj = stack_pointer[-1];
            unaryfunc getter = NULL;
            PyTypeObject *type = Py_TYPE(obj);

            if (type->tp_as_async != NULL) {
                getter = type->tp_as_async->am_aiter;
            }

            if (getter == NULL) {
                _PyErr_Format(tstate, PyExc_TypeError,
                              "'async for' requires an object with "
                              "__aiter__ method, got %.100s",
                              type->tp_name);
                Py_DECREF(obj);
                if (true) goto pop_1_error_tier_two;
            }

            iter = (*getter)(obj);
            Py_DECREF(obj);
            if (iter == NULL) goto pop_1_error_tier_two;

            if (Py_TYPE(iter)->tp_as_async == NULL ||
                    Py_TYPE(iter)->tp_as_async->am_anext == NULL) {

                _PyErr_Format(tstate, PyExc_TypeError,
                              "'async for' received an object from __aiter__ "
                              "that does not implement __anext__: %.100s",
                              Py_TYPE(iter)->tp_name);
                Py_DECREF(iter);
                if (true) goto pop_1_error_tier_two;
            }
            stack_pointer[-1] = iter;
            break;
        }

        case GET_ANEXT: {
            PyObject *aiter;
            PyObject *awaitable;
            aiter = stack_pointer[-1];
            unaryfunc getter = NULL;
            PyObject *next_iter = NULL;
            PyTypeObject *type = Py_TYPE(aiter);

            if (PyAsyncGen_CheckExact(aiter)) {
                awaitable = type->tp_as_async->am_anext(aiter);
                if (awaitable == NULL) {
                    GOTO_ERROR(error);
                }
            } else {
                if (type->tp_as_async != NULL){
                    getter = type->tp_as_async->am_anext;
                }

                if (getter != NULL) {
                    next_iter = (*getter)(aiter);
                    if (next_iter == NULL) {
                        GOTO_ERROR(error);
                    }
                }
                else {
                    _PyErr_Format(tstate, PyExc_TypeError,
                                  "'async for' requires an iterator with "
                                  "__anext__ method, got %.100s",
                                  type->tp_name);
                    GOTO_ERROR(error);
                }

                awaitable = _PyCoro_GetAwaitableIter(next_iter);
                if (awaitable == NULL) {
                    _PyErr_FormatFromCause(
                        PyExc_TypeError,
                        "'async for' received an invalid object "
                        "from __anext__: %.100s",
                        Py_TYPE(next_iter)->tp_name);

                    Py_DECREF(next_iter);
                    GOTO_ERROR(error);
                } else {
                    Py_DECREF(next_iter);
                }
            }
            STACK_GROW(1);
            stack_pointer[-1] = awaitable;
            break;
        }

        case GET_AWAITABLE: {
            oparg = CURRENT_OPARG();
            PyObject *iterable;
            PyObject *iter;
            iterable = stack_pointer[-1];
            iter = _PyCoro_GetAwaitableIter(iterable);

            if (iter == NULL) {
                _PyEval_FormatAwaitableError(tstate, Py_TYPE(iterable), oparg);
            }

            Py_DECREF(iterable);

            if (iter != NULL && PyCoro_CheckExact(iter)) {
                PyObject *yf = _PyGen_yf((PyGenObject*)iter);
                if (yf != NULL) {
                    /* `iter` is a coroutine object that is being
                       awaited, `yf` is a pointer to the current awaitable
                       being awaited on. */
                    Py_DECREF(yf);
                    Py_CLEAR(iter);
                    _PyErr_SetString(tstate, PyExc_RuntimeError,
                                     "coroutine is being awaited already");
                    /* The code below jumps to `error` if `iter` is NULL. */
                }
            }

            if (iter == NULL) goto pop_1_error_tier_two;
            stack_pointer[-1] = iter;
            break;
        }

        case POP_EXCEPT: {
            PyObject *exc_value;
            exc_value = stack_pointer[-1];
            _PyErr_StackItem *exc_info = tstate->exc_info;
            Py_XSETREF(exc_info->exc_value, exc_value);
            STACK_SHRINK(1);
            break;
        }

        case LOAD_ASSERTION_ERROR: {
            PyObject *value;
            value = Py_NewRef(PyExc_AssertionError);
            STACK_GROW(1);
            stack_pointer[-1] = value;
            break;
        }

        case LOAD_BUILD_CLASS: {
            PyObject *bc;
            if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc) < 0) goto error_tier_two;
            if (bc == NULL) {
                _PyErr_SetString(tstate, PyExc_NameError,
                                 "__build_class__ not found");
                if (true) goto error_tier_two;
            }
            STACK_GROW(1);
            stack_pointer[-1] = bc;
            break;
        }

        case STORE_NAME: {
            oparg = CURRENT_OPARG();
            PyObject *v;
            v = stack_pointer[-1];
            PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
            PyObject *ns = LOCALS();
            int err;
            if (ns == NULL) {
                _PyErr_Format(tstate, PyExc_SystemError,
                              "no locals found when storing %R", name);
                Py_DECREF(v);
                if (true) goto pop_1_error_tier_two;
            }
            if (PyDict_CheckExact(ns))
                err = PyDict_SetItem(ns, name, v);
            else
                err = PyObject_SetItem(ns, name, v);
            Py_DECREF(v);
            if (err) goto pop_1_error_tier_two;
            STACK_SHRINK(1);
            break;
        }

        case DELETE_NAME: {
            oparg = CURRENT_OPARG();
            PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
            PyObject *ns = LOCALS();
            int err;
            if (ns == NULL) {
                _PyErr_Format(tstate, PyExc_SystemError,
                              "no locals when deleting %R", name);
                GOTO_ERROR(error);
            }
            err = PyObject_DelItem(ns, name);
            // Can't use ERROR_IF here.
            if (err != 0) {
                _PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
                                          NAME_ERROR_MSG,
                                          name);
                GOTO_ERROR(error);
            }
            break;
        }

        case _UNPACK_SEQUENCE: {
            oparg = CURRENT_OPARG();
            PyObject *seq;
            seq = stack_pointer[-1];
            PyObject **top = stack_pointer + oparg - 1;
            int res = _PyEval_UnpackIterable(tstate, seq, oparg, -1, top);
            Py_DECREF(seq);
            if (res == 0) goto pop_1_error_tier_two;
            STACK_SHRINK(1);
            STACK_GROW(oparg);
            break;
        }

        case UNPACK_SEQUENCE_TWO_TUPLE: {
            oparg = CURRENT_OPARG();
            PyObject *seq;
            PyObject **values;
            seq = stack_pointer[-1];
            values = stack_pointer - 1;
            DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
            DEOPT_IF(PyTuple_GET_SIZE(seq) != 2, UNPACK_SEQUENCE);
            assert(oparg == 2);
            STAT_INC(UNPACK_SEQUENCE, hit);
            values[0] = Py_NewRef(PyTuple_GET_ITEM(seq, 1));
            values[1] = Py_NewRef(PyTuple_GET_ITEM(seq, 0));
            Py_DECREF(seq);
            STACK_SHRINK(1);
            STACK_GROW(oparg);
            break;
        }

        case UNPACK_SEQUENCE_TUPLE: {
            oparg = CURRENT_OPARG();
            PyObject *seq;
            PyObject **values;
            seq = stack_pointer[-1];
            values = stack_pointer - 1;
            DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
            DEOPT_IF(PyTuple_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
            STAT_INC(UNPACK_SEQUENCE, hit);
            PyObject **items = _PyTuple_ITEMS(seq);
            for (int i = oparg; --i >= 0; ) {
                *values++ = Py_NewRef(items[i]);
            }
            Py_DECREF(seq);
            STACK_SHRINK(1);
            STACK_GROW(oparg);
            break;
        }

        case UNPACK_SEQUENCE_LIST: {
            oparg = CURRENT_OPARG();
            PyObject *seq;
            PyObject **values;
            seq = stack_pointer[-1];
            values = stack_pointer - 1;
            DEOPT_IF(!PyList_CheckExact(seq), UNPACK_SEQUENCE);
            DEOPT_IF(PyList_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
            STAT_INC(UNPACK_SEQUENCE, hit);
            PyObject **items = _PyList_ITEMS(seq);
            for (int i = oparg; --i >= 0; ) {
                *values++ = Py_NewRef(items[i]);
            }
            Py_DECREF(seq);
            STACK_SHRINK(1);
            STACK_GROW(oparg);
            break;
        }

        case UNPACK_EX: {
            oparg = CURRENT_OPARG();
            PyObject *seq;
            seq = stack_pointer[-1];
            int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
            PyObject **top = stack_pointer + totalargs - 1;
            int res = _PyEval_UnpackIterable(tstate, seq, oparg & 0xFF, oparg >> 8, top);
            Py_DECREF(seq);
            if (res == 0) goto pop_1_error_tier_two;
            STACK_GROW((oparg & 0xFF) + (oparg >> 8));
            break;
        }

        case _STORE_ATTR: {
            oparg = CURRENT_OPARG();
            PyObject *owner;
            PyObject *v;
            owner = stack_pointer[-1];
            v = stack_pointer[-2];
            PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
            int err = PyObject_SetAttr(owner, name, v);
            Py_DECREF(v);
            Py_DECREF(owner);
            if (err) goto pop_2_error_tier_two;
            STACK_SHRINK(2);
            break;
        }

        case DELETE_ATTR: {
            oparg = CURRENT_OPARG();
            PyObject *owner;
            owner = stack_pointer[-1];
            PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
            int err = PyObject_DelAttr(owner, name);
            Py_DECREF(owner);
            if (err) goto pop_1_error_tier_two;
            STACK_SHRINK(1);
            break;
        }

        case STORE_GLOBAL: {
            oparg = CURRENT_OPARG();
            PyObject *v;
            v = stack_pointer[-1];
            PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
            int err = PyDict_SetItem(GLOBALS(), name, v);
            Py_DECREF(v);
            if (err) goto pop_1_error_tier_two;
            STACK_SHRINK(1);
            break;
        }