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;

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: {

PyObject *value;

value = GETLOCAL(oparg);

if (value == NULL) goto unbound_local_error;

Py_INCREF(value);

STACK_GROW(1);

stack_pointer[-1] = value;

break;

}

case LOAD_FAST: {

PyObject *value;

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

STACK_GROW(1);

stack_pointer[-1] = value;

break;

}

case LOAD_FAST_AND_CLEAR: {

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: {

PyObject *value;

value = GETITEM(FRAME_CO_CONSTS, oparg);

Py_INCREF(value);

STACK_GROW(1);

stack_pointer[-1] = value;

break;

}

case STORE_FAST: {

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;

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];

#if ENABLE_SPECIALIZATION

_PyToBoolCache *cache = (_PyToBoolCache *)next_instr;

if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {

next_instr--;

_Py_Specialize_ToBool(value, next_instr);

DISPATCH_SAME_OPARG();

}

STAT_INC(TO_BOOL, deferred);

DECREMENT_ADAPTIVE_COUNTER(cache->counter);

#endif /* ENABLE_SPECIALIZATION */

int err = PyObject_IsTrue(value);

Py_DECREF(value);

if (err < 0) goto pop_1_error;

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)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;

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;

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;

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;

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;

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];

#if ENABLE_SPECIALIZATION

_PyBinarySubscrCache *cache = (_PyBinarySubscrCache *)next_instr;

if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {

next_instr--;

_Py_Specialize_BinarySubscr(container, sub, next_instr);

DISPATCH_SAME_OPARG();

}

STAT_INC(BINARY_SUBSCR, deferred);

DECREMENT_ADAPTIVE_COUNTER(cache->counter);

#endif /* ENABLE_SPECIALIZATION */

res = PyObject_GetItem(container, sub);

Py_DECREF(container);

Py_DECREF(sub);

if (res == NULL) goto pop_2_error;

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;

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;

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);

res = PyDict_GetItemWithError(dict, sub);

if (res == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_SetKeyError(sub);

}

Py_DECREF(dict);

Py_DECREF(sub);

if (true) goto pop_2_error;

}

Py_INCREF(res); // Do this before DECREF'ing dict, sub

Py_DECREF(dict);

Py_DECREF(sub);

STACK_SHRINK(1);

stack_pointer[-1] = res;

break;

}

case LIST_APPEND: {

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;

STACK_SHRINK(1);

break;

}

case SET_ADD: {

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;

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];

#if ENABLE_SPECIALIZATION

_PyStoreSubscrCache *cache = (_PyStoreSubscrCache *)next_instr;

if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {

next_instr--;

_Py_Specialize_StoreSubscr(container, sub, next_instr);

DISPATCH_SAME_OPARG();

}

STAT_INC(STORE_SUBSCR, deferred);

DECREMENT_ADAPTIVE_COUNTER(cache->counter);

#endif /* ENABLE_SPECIALIZATION */

/* 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;

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;

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;

STACK_SHRINK(2);

break;

}

case CALL_INTRINSIC_1: {

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;

stack_pointer[-1] = res;

break;

}

case CALL_INTRINSIC_2: {

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;

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;

}

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;

}

iter = (*getter)(obj);

Py_DECREF(obj);

if (iter == NULL) goto pop_1_error;

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;

}

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;

}

} else {

if (type->tp_as_async != NULL){

getter = type->tp_as_async->am_anext;

}

if (getter != NULL) {

next_iter = (*getter)(aiter);

if (next_iter == NULL) {

goto error;

}

}

else {

_PyErr_Format(tstate, PyExc_TypeError,

"'async for' requires an iterator with "

"__anext__ method, got %.100s",

type->tp_name);

goto error;

}

awaitable = _PyCoro_GetAwaitableIter(next_iter);

if (awaitable == NULL) {

_PyErr_FormatFromCause(

PyExc_TypeError,

"'async for' received an invalid object "

"from __anext__: %.100s",

Py_TYPE(next_iter)->tp_name);

Py_DECREF(next_iter);

goto error;

} else {

Py_DECREF(next_iter);

}

}

STACK_GROW(1);

stack_pointer[-1] = awaitable;

break;

}

case GET_AWAITABLE: {

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

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;

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;

if (bc == NULL) {

_PyErr_SetString(tstate, PyExc_NameError,

"__build_class__ not found");

if (true) goto error;

}

STACK_GROW(1);

stack_pointer[-1] = bc;

break;

}

case STORE_NAME: {

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;

}

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;

STACK_SHRINK(1);

break;

}

case DELETE_NAME: {

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;

}

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;

}

break;

}

case UNPACK_SEQUENCE: {

PyObject *seq;

seq = stack_pointer[-1];

#if ENABLE_SPECIALIZATION

_PyUnpackSequenceCache *cache = (_PyUnpackSequenceCache *)next_instr;

if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {

next_instr--;

_Py_Specialize_UnpackSequence(seq, next_instr, oparg);

DISPATCH_SAME_OPARG();

}

STAT_INC(UNPACK_SEQUENCE, deferred);

DECREMENT_ADAPTIVE_COUNTER(cache->counter);

#endif /* ENABLE_SPECIALIZATION */

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;

STACK_SHRINK(1);

STACK_GROW(oparg);

break;

}

case UNPACK_SEQUENCE_TWO_TUPLE: {

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: {

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: {

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: {

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;

STACK_GROW((oparg & 0xFF) + (oparg >> 8));

break;

}

case STORE_ATTR: {

PyObject *owner;

PyObject *v;

owner = stack_pointer[-1];

v = stack_pointer[-2];

#if ENABLE_SPECIALIZATION

_PyAttrCache *cache = (_PyAttrCache *)next_instr;

if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {

PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);

next_instr--;

_Py_Specialize_StoreAttr(owner, next_instr, name);

DISPATCH_SAME_OPARG();

}

STAT_INC(STORE_ATTR, deferred);

DECREMENT_ADAPTIVE_COUNTER(cache->counter);