TARGET(NOP) {

DISPATCH();

}

TARGET(RESUME) {

#line 137 "Python/bytecodes.c"

assert(tstate->cframe == &cframe);

assert(frame == cframe.current_frame);

/* Possibly combine this with eval breaker */

if (frame->f_code->_co_instrumentation_version != tstate->interp->monitoring_version) {

int err = _Py_Instrument(frame->f_code, tstate->interp);

if (err) goto error;

next_instr--;

}

else if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {

goto handle_eval_breaker;

}

#line 24 "Python/generated_cases.c.h"

DISPATCH();

}

TARGET(INSTRUMENTED_RESUME) {

#line 151 "Python/bytecodes.c"

/* Possible performance enhancement:

if (frame->f_code->_co_instrumentation_version != tstate->interp->monitoring_version) {

if (_Py_Instrument(frame->f_code, tstate->interp)) {

goto error;

}

next_instr--;

}

else {

_PyFrame_SetStackPointer(frame, stack_pointer);

int err = _Py_call_instrumentation(

tstate, oparg > 0, frame, next_instr-1);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (err) goto error;

if (frame->prev_instr != next_instr-1) {

/* Instrumentation has jumped */

next_instr = frame->prev_instr;

DISPATCH();

}

if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {

goto handle_eval_breaker;

}

}

#line 55 "Python/generated_cases.c.h"

DISPATCH();

}

TARGET(LOAD_CLOSURE) {

PyObject *value;

#line 179 "Python/bytecodes.c"

/* We keep LOAD_CLOSURE so that the bytecode stays more readable. */

value = GETLOCAL(oparg);

if (value == NULL) goto unbound_local_error;

Py_INCREF(value);

#line 66 "Python/generated_cases.c.h"

STACK_GROW(1);

stack_pointer[-1] = value;

DISPATCH();

}

TARGET(LOAD_FAST_CHECK) {

PyObject *value;

#line 186 "Python/bytecodes.c"

value = GETLOCAL(oparg);

if (value == NULL) goto unbound_local_error;

Py_INCREF(value);

#line 78 "Python/generated_cases.c.h"

STACK_GROW(1);

stack_pointer[-1] = value;

DISPATCH();

}

TARGET(LOAD_FAST) {

PyObject *value;

#line 192 "Python/bytecodes.c"

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

#line 90 "Python/generated_cases.c.h"

STACK_GROW(1);

stack_pointer[-1] = value;

DISPATCH();

}

TARGET(LOAD_CONST) {

PREDICTED(LOAD_CONST);

PyObject *value;

#line 198 "Python/bytecodes.c"

value = GETITEM(frame->f_code->co_consts, oparg);

Py_INCREF(value);

#line 102 "Python/generated_cases.c.h"

STACK_GROW(1);

stack_pointer[-1] = value;

DISPATCH();

}

TARGET(STORE_FAST) {

PyObject *value = stack_pointer[-1];

#line 203 "Python/bytecodes.c"

SETLOCAL(oparg, value);

#line 112 "Python/generated_cases.c.h"

STACK_SHRINK(1);

DISPATCH();

}

TARGET(LOAD_FAST__LOAD_FAST) {

PyObject *_tmp_1;

PyObject *_tmp_2;

{

PyObject *value;

#line 192 "Python/bytecodes.c"

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

#line 126 "Python/generated_cases.c.h"

_tmp_2 = value;

}

oparg = (next_instr++)->op.arg;

{

PyObject *value;

#line 192 "Python/bytecodes.c"

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

#line 136 "Python/generated_cases.c.h"

_tmp_1 = value;

}

STACK_GROW(2);

stack_pointer[-1] = _tmp_1;

stack_pointer[-2] = _tmp_2;

DISPATCH();

}

TARGET(LOAD_FAST__LOAD_CONST) {

PyObject *_tmp_1;

PyObject *_tmp_2;

{

PyObject *value;

#line 192 "Python/bytecodes.c"

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

#line 154 "Python/generated_cases.c.h"

_tmp_2 = value;

}

oparg = (next_instr++)->op.arg;

{

PyObject *value;

#line 198 "Python/bytecodes.c"

value = GETITEM(frame->f_code->co_consts, oparg);

Py_INCREF(value);

#line 163 "Python/generated_cases.c.h"

_tmp_1 = value;

}

STACK_GROW(2);

stack_pointer[-1] = _tmp_1;

stack_pointer[-2] = _tmp_2;

DISPATCH();

}

TARGET(STORE_FAST__LOAD_FAST) {

PyObject *_tmp_1 = stack_pointer[-1];

{

PyObject *value = _tmp_1;

#line 203 "Python/bytecodes.c"

SETLOCAL(oparg, value);

#line 178 "Python/generated_cases.c.h"

}

oparg = (next_instr++)->op.arg;

{

PyObject *value;

#line 192 "Python/bytecodes.c"

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

#line 187 "Python/generated_cases.c.h"

_tmp_1 = value;

}

stack_pointer[-1] = _tmp_1;

DISPATCH();

}

TARGET(STORE_FAST__STORE_FAST) {

PyObject *_tmp_1 = stack_pointer[-1];

PyObject *_tmp_2 = stack_pointer[-2];

{

PyObject *value = _tmp_1;

#line 203 "Python/bytecodes.c"

SETLOCAL(oparg, value);

#line 201 "Python/generated_cases.c.h"

}

oparg = (next_instr++)->op.arg;

{

PyObject *value = _tmp_2;

#line 203 "Python/bytecodes.c"

SETLOCAL(oparg, value);

#line 208 "Python/generated_cases.c.h"

}

STACK_SHRINK(2);

DISPATCH();

}

TARGET(LOAD_CONST__LOAD_FAST) {

PyObject *_tmp_1;

PyObject *_tmp_2;

{

PyObject *value;

#line 198 "Python/bytecodes.c"

value = GETITEM(frame->f_code->co_consts, oparg);

Py_INCREF(value);

#line 222 "Python/generated_cases.c.h"

_tmp_2 = value;

}

oparg = (next_instr++)->op.arg;

{

PyObject *value;

#line 192 "Python/bytecodes.c"

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

#line 232 "Python/generated_cases.c.h"

_tmp_1 = value;

}

STACK_GROW(2);

stack_pointer[-1] = _tmp_1;

stack_pointer[-2] = _tmp_2;

DISPATCH();

}

TARGET(POP_TOP) {

PyObject *value = stack_pointer[-1];

#line 213 "Python/bytecodes.c"

#line 244 "Python/generated_cases.c.h"

Py_DECREF(value);

STACK_SHRINK(1);

DISPATCH();

}

TARGET(PUSH_NULL) {

PyObject *res;

#line 217 "Python/bytecodes.c"

res = NULL;

#line 254 "Python/generated_cases.c.h"

STACK_GROW(1);

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(END_FOR) {

PyObject *_tmp_1 = stack_pointer[-1];

PyObject *_tmp_2 = stack_pointer[-2];

{

PyObject *value = _tmp_1;

#line 213 "Python/bytecodes.c"

#line 266 "Python/generated_cases.c.h"

Py_DECREF(value);

}

{

PyObject *value = _tmp_2;

#line 213 "Python/bytecodes.c"

#line 272 "Python/generated_cases.c.h"

Py_DECREF(value);

}

STACK_SHRINK(2);

DISPATCH();

}

TARGET(INSTRUMENTED_END_FOR) {

PyObject *value = stack_pointer[-1];

PyObject *receiver = stack_pointer[-2];

#line 223 "Python/bytecodes.c"

/* Need to create a fake StopIteration error here,

if (PyGen_Check(receiver)) {

PyErr_SetObject(PyExc_StopIteration, value);

if (monitor_stop_iteration(tstate, frame, next_instr-1)) {

goto error;

}

PyErr_SetRaisedException(NULL);

}

#line 292 "Python/generated_cases.c.h"

Py_DECREF(receiver);

Py_DECREF(value);

STACK_SHRINK(2);

DISPATCH();

}

TARGET(END_SEND) {

PyObject *value = stack_pointer[-1];

PyObject *receiver = stack_pointer[-2];

#line 236 "Python/bytecodes.c"

Py_DECREF(receiver);

#line 304 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = value;

DISPATCH();

}

TARGET(INSTRUMENTED_END_SEND) {

PyObject *value = stack_pointer[-1];

PyObject *receiver = stack_pointer[-2];

#line 240 "Python/bytecodes.c"

if (PyGen_Check(receiver) || PyCoro_CheckExact(receiver)) {

PyErr_SetObject(PyExc_StopIteration, value);

if (monitor_stop_iteration(tstate, frame, next_instr-1)) {

goto error;

}

PyErr_SetRaisedException(NULL);

}

Py_DECREF(receiver);

#line 322 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = value;

DISPATCH();

}

TARGET(UNARY_NEGATIVE) {

PyObject *value = stack_pointer[-1];

PyObject *res;

#line 251 "Python/bytecodes.c"

res = PyNumber_Negative(value);

#line 333 "Python/generated_cases.c.h"

Py_DECREF(value);

#line 253 "Python/bytecodes.c"

if (res == NULL) goto pop_1_error;

#line 337 "Python/generated_cases.c.h"

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(UNARY_NOT) {

PyObject *value = stack_pointer[-1];

PyObject *res;

#line 257 "Python/bytecodes.c"

int err = PyObject_IsTrue(value);

#line 347 "Python/generated_cases.c.h"

Py_DECREF(value);

#line 259 "Python/bytecodes.c"

if (err < 0) goto pop_1_error;

if (err == 0) {

res = Py_True;

}

else {

res = Py_False;

}

Py_INCREF(res);

#line 358 "Python/generated_cases.c.h"

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(UNARY_INVERT) {

PyObject *value = stack_pointer[-1];

PyObject *res;

#line 270 "Python/bytecodes.c"

res = PyNumber_Invert(value);

#line 368 "Python/generated_cases.c.h"

Py_DECREF(value);

#line 272 "Python/bytecodes.c"

if (res == NULL) goto pop_1_error;

#line 372 "Python/generated_cases.c.h"

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(BINARY_OP_MULTIPLY_INT) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *prod;

#line 289 "Python/bytecodes.c"

DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);

STAT_INC(BINARY_OP, hit);

prod = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right);

_Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);

_Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

if (prod == NULL) goto pop_2_error;

#line 389 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = prod;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_OP_MULTIPLY_FLOAT) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *prod;

#line 299 "Python/bytecodes.c"

DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);

STAT_INC(BINARY_OP, hit);

double dprod = ((PyFloatObject *)left)->ob_fval *

((PyFloatObject *)right)->ob_fval;

DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dprod, prod);

#line 407 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = prod;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_OP_SUBTRACT_INT) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *sub;

#line 308 "Python/bytecodes.c"

DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);

STAT_INC(BINARY_OP, hit);

sub = _PyLong_Subtract((PyLongObject *)left, (PyLongObject *)right);

_Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);

_Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

if (sub == NULL) goto pop_2_error;

#line 426 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = sub;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_OP_SUBTRACT_FLOAT) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *sub;

#line 318 "Python/bytecodes.c"

DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);

STAT_INC(BINARY_OP, hit);

double dsub = ((PyFloatObject *)left)->ob_fval - ((PyFloatObject *)right)->ob_fval;

DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dsub, sub);

#line 443 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = sub;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_OP_ADD_UNICODE) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *res;

#line 326 "Python/bytecodes.c"

DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);

DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);

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;

#line 462 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = res;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_OP_INPLACE_ADD_UNICODE) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

#line 342 "Python/bytecodes.c"

DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);

DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);

_Py_CODEUNIT true_next = next_instr[INLINE_CACHE_ENTRIES_BINARY_OP];

assert(true_next.op.code == STORE_FAST ||

true_next.op.code == STORE_FAST__LOAD_FAST);

PyObject **target_local = &GETLOCAL(true_next.op.arg);

DEOPT_IF(*target_local != left, BINARY_OP);

STAT_INC(BINARY_OP, hit);

/* Handle `left = left + right` or `left += right` for str.

assert(Py_REFCNT(left) >= 2);

_Py_DECREF_NO_DEALLOC(left);

PyUnicode_Append(target_local, right);

_Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);

if (*target_local == NULL) goto pop_2_error;

// The STORE_FAST is already done.

JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP + 1);

#line 499 "Python/generated_cases.c.h"

STACK_SHRINK(2);

DISPATCH();

}

TARGET(BINARY_OP_ADD_FLOAT) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *sum;

#line 371 "Python/bytecodes.c"

DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);

DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);

STAT_INC(BINARY_OP, hit);

double dsum = ((PyFloatObject *)left)->ob_fval +

((PyFloatObject *)right)->ob_fval;

DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dsum, sum);

#line 515 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = sum;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_OP_ADD_INT) {

PyObject *right = stack_pointer[-1];

PyObject *left = stack_pointer[-2];

PyObject *sum;

#line 380 "Python/bytecodes.c"

DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);

DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);

STAT_INC(BINARY_OP, hit);

sum = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right);

_Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);

_Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

if (sum == NULL) goto pop_2_error;

#line 534 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = sum;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_SUBSCR) {

PREDICTED(BINARY_SUBSCR);

static_assert(INLINE_CACHE_ENTRIES_BINARY_SUBSCR == 1, "incorrect cache size");

PyObject *sub = stack_pointer[-1];

PyObject *container = stack_pointer[-2];

PyObject *res;

#line 398 "Python/bytecodes.c"

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

#line 559 "Python/generated_cases.c.h"

Py_DECREF(container);

Py_DECREF(sub);

#line 410 "Python/bytecodes.c"

if (res == NULL) goto pop_2_error;

#line 564 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = res;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_SLICE) {

PyObject *stop = stack_pointer[-1];

PyObject *start = stack_pointer[-2];

PyObject *container = stack_pointer[-3];

PyObject *res;

#line 414 "Python/bytecodes.c"

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;

#line 589 "Python/generated_cases.c.h"

STACK_SHRINK(2);

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(STORE_SLICE) {

PyObject *stop = stack_pointer[-1];

PyObject *start = stack_pointer[-2];

PyObject *container = stack_pointer[-3];

PyObject *v = stack_pointer[-4];

#line 429 "Python/bytecodes.c"

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;

#line 613 "Python/generated_cases.c.h"

STACK_SHRINK(4);

DISPATCH();

}

TARGET(BINARY_SUBSCR_LIST_INT) {

PyObject *sub = stack_pointer[-1];

PyObject *list = stack_pointer[-2];

PyObject *res;

#line 444 "Python/bytecodes.c"

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

#line 636 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = res;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_TUPLE_INT) {

PyObject *sub = stack_pointer[-1];

PyObject *tuple = stack_pointer[-2];

PyObject *res;

#line 460 "Python/bytecodes.c"

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

#line 661 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = res;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_DICT) {

PyObject *sub = stack_pointer[-1];

PyObject *dict = stack_pointer[-2];

PyObject *res;

#line 476 "Python/bytecodes.c"

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

}

#line 680 "Python/generated_cases.c.h"

Py_DECREF(dict);

Py_DECREF(sub);

#line 484 "Python/bytecodes.c"

if (true) goto pop_2_error;

}

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

#line 687 "Python/generated_cases.c.h"

Py_DECREF(dict);

Py_DECREF(sub);

STACK_SHRINK(1);

stack_pointer[-1] = res;

next_instr += 1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_GETITEM) {

PyObject *sub = stack_pointer[-1];

PyObject *container = stack_pointer[-2];

#line 491 "Python/bytecodes.c"

PyTypeObject *tp = Py_TYPE(container);

DEOPT_IF(!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE), BINARY_SUBSCR);

PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;

PyObject *cached = ht->_spec_cache.getitem;

DEOPT_IF(cached == NULL, BINARY_SUBSCR);

assert(PyFunction_Check(cached));

PyFunctionObject *getitem = (PyFunctionObject *)cached;

uint32_t cached_version = ht->_spec_cache.getitem_version;

DEOPT_IF(getitem->func_version != cached_version, BINARY_SUBSCR);

PyCodeObject *code = (PyCodeObject *)getitem->func_code;

assert(code->co_argcount == 2);

DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), BINARY_SUBSCR);

STAT_INC(BINARY_SUBSCR, hit);

Py_INCREF(getitem);

_PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, getitem, 2);

STACK_SHRINK(2);

new_frame->localsplus[0] = container;

new_frame->localsplus[1] = sub;

JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);

frame->return_offset = 0;

DISPATCH_INLINED(new_frame);

#line 721 "Python/generated_cases.c.h"

}

TARGET(LIST_APPEND) {

PyObject *v = stack_pointer[-1];

PyObject *list = stack_pointer[-(2 + (oparg-1))];

#line 515 "Python/bytecodes.c"

if (_PyList_AppendTakeRef((PyListObject *)list, v) < 0) goto pop_1_error;

#line 729 "Python/generated_cases.c.h"

STACK_SHRINK(1);

PREDICT(JUMP_BACKWARD);

DISPATCH();

}

TARGET(SET_ADD) {

PyObject *v = stack_pointer[-1];

PyObject *set = stack_pointer[-(2 + (oparg-1))];

#line 520 "Python/bytecodes.c"

int err = PySet_Add(set, v);

#line 740 "Python/generated_cases.c.h"

Py_DECREF(v);

#line 522 "Python/bytecodes.c"

if (err) goto pop_1_error;

#line 744 "Python/generated_cases.c.h"

STACK_SHRINK(1);

PREDICT(JUMP_BACKWARD);

DISPATCH();

}

TARGET(STORE_SUBSCR) {

PREDICTED(STORE_SUBSCR);

static_assert(INLINE_CACHE_ENTRIES_STORE_SUBSCR == 1, "incorrect cache size");

PyObject *sub = stack_pointer[-1];

PyObject *container = stack_pointer[-2];

PyObject *v = stack_pointer[-3];

uint16_t counter = read_u16(&next_instr[0].cache);

#line 533 "Python/bytecodes.c"

#if ENABLE_SPECIALIZATION

if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {

next_instr--;

_Py_Specialize_StoreSubscr(container, sub, next_instr);

DISPATCH_SAME_OPARG();

}

STAT_INC(STORE_SUBSCR, deferred);

_PyStoreSubscrCache *cache = (_PyStoreSubscrCache *)next_instr;

DECREMENT_ADAPTIVE_COUNTER(cache->counter);

#else

(void)counter; // Unused.

#endif /* ENABLE_SPECIALIZATION */

/* container[sub] = v */

int err = PyObject_SetItem(container, sub, v);

#line 772 "Python/generated_cases.c.h"

Py_DECREF(v);

Py_DECREF(container);

Py_DECREF(sub);

#line 548 "Python/bytecodes.c"

if (err) goto pop_3_error;

#line 778 "Python/generated_cases.c.h"

STACK_SHRINK(3);

next_instr += 1;

DISPATCH();

}

TARGET(STORE_SUBSCR_LIST_INT) {

PyObject *sub = stack_pointer[-1];

PyObject *list = stack_pointer[-2];

PyObject *value = stack_pointer[-3];

#line 552 "Python/bytecodes.c"

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

#line 805 "Python/generated_cases.c.h"

STACK_SHRINK(3);

next_instr += 1;

DISPATCH();

}

TARGET(STORE_SUBSCR_DICT) {

PyObject *sub = stack_pointer[-1];

PyObject *dict = stack_pointer[-2];

PyObject *value = stack_pointer[-3];

#line 571 "Python/bytecodes.c"

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;

#line 821 "Python/generated_cases.c.h"

STACK_SHRINK(3);

next_instr += 1;

DISPATCH();

}

TARGET(DELETE_SUBSCR) {

PyObject *sub = stack_pointer[-1];

PyObject *container = stack_pointer[-2];

#line 579 "Python/bytecodes.c"

/* del container[sub] */

int err = PyObject_DelItem(container, sub);

#line 833 "Python/generated_cases.c.h"

Py_DECREF(container);

Py_DECREF(sub);

#line 582 "Python/bytecodes.c"

if (err) goto pop_2_error;

#line 838 "Python/generated_cases.c.h"

STACK_SHRINK(2);

DISPATCH();

}

TARGET(CALL_INTRINSIC_1) {

PyObject *value = stack_pointer[-1];

PyObject *res;

#line 586 "Python/bytecodes.c"

assert(oparg <= MAX_INTRINSIC_1);

res = _PyIntrinsics_UnaryFunctions[oparg](tstate, value);

#line 849 "Python/generated_cases.c.h"

Py_DECREF(value);

#line 589 "Python/bytecodes.c"

if (res == NULL) goto pop_1_error;

#line 853 "Python/generated_cases.c.h"

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(CALL_INTRINSIC_2) {

PyObject *value1 = stack_pointer[-1];

PyObject *value2 = stack_pointer[-2];

PyObject *res;

#line 593 "Python/bytecodes.c"

assert(oparg <= MAX_INTRINSIC_2);

res = _PyIntrinsics_BinaryFunctions[oparg](tstate, value2, value1);

#line 865 "Python/generated_cases.c.h"

Py_DECREF(value2);

Py_DECREF(value1);

#line 596 "Python/bytecodes.c"

if (res == NULL) goto pop_2_error;

#line 870 "Python/generated_cases.c.h"

STACK_SHRINK(1);

stack_pointer[-1] = res;

DISPATCH();

}

TARGET(RAISE_VARARGS) {

PyObject **args = (stack_pointer - oparg);

#line 600 "Python/bytecodes.c"

PyObject *cause = NULL, *exc = NULL;

switch (oparg) {

case 2:

cause = args[1];

/* fall through */

case 1:

exc = args[0];

/* fall through */

case 0:

if (do_raise(tstate, exc, cause)) { STACK_SHRINK(oparg); goto exception_unwind; }

break;

default:

_PyErr_SetString(tstate, PyExc_SystemError,

"bad RAISE_VARARGS oparg");

break;

}

if (true) { STACK_SHRINK(oparg); goto error; }

#line 896 "Python/generated_cases.c.h"

}

TARGET(INTERPRETER_EXIT) {

PyObject *retval = stack_pointer[-1];

#line 620 "Python/bytecodes.c"

assert(frame == &entry_frame);

assert(_PyFrame_IsIncomplete(frame));

STACK_SHRINK(1); // Since we're not going to DISPATCH()

assert(EMPTY());

/* Restore previous cframe and return. */

tstate->cframe = cframe.previous;

assert(tstate->cframe->current_frame == frame->previous);

assert(!_PyErr_Occurred(tstate));

_Py_LeaveRecursiveCallTstate(tstate);

return retval;

#line 912 "Python/generated_cases.c.h"

}

TARGET(RETURN_VALUE) {

PyObject *retval = stack_pointer[-1];

#line 633 "Python/bytecodes.c"

STACK_SHRINK(1);

assert(EMPTY());

_PyFrame_SetStackPointer(frame, stack_pointer);

_Py_LeaveRecursiveCallPy(tstate);

assert(frame != &entry_frame);

// GH-99729: We need to unlink the frame *before* clearing it:

_PyInterpreterFrame *dying = frame;

frame = cframe.current_frame = dying->previous;

_PyEvalFrameClearAndPop(tstate, dying);

frame->prev_instr += frame->return_offset;

_PyFrame_StackPush(frame, retval);

goto resume_frame;

#line 930 "Python/generated_cases.c.h"

}

TARGET(INSTRUMENTED_RETURN_VALUE) {

PyObject *retval = stack_pointer[-1];

#line 648 "Python/bytecodes.c"

int err = _Py_call_instrumentation_arg(

tstate, PY_MONITORING_EVENT_PY_RETURN,

frame, next_instr-1, retval);

if (err) goto error;

STACK_SHRINK(1);

assert(EMPTY());

_PyFrame_SetStackPointer(frame, stack_pointer);

_Py_LeaveRecursiveCallPy(tstate);

assert(frame != &entry_frame);

// GH-99729: We need to unlink the frame *before* clearing it:

_PyInterpreterFrame *dying = frame;

frame = cframe.current_frame = dying->previous;

_PyEvalFrameClearAndPop(tstate, dying);

frame->prev_instr += frame->return_offset;

_PyFrame_StackPush(frame, retval);

goto resume_frame;

#line 952 "Python/generated_cases.c.h"

}

TARGET(RETURN_CONST) {

#line 667 "Python/bytecodes.c"

PyObject *retval = GETITEM(frame->f_code->co_consts, oparg);

Py_INCREF(retval);

assert(EMPTY());

_PyFrame_SetStackPointer(frame, stack_pointer);

_Py_LeaveRecursiveCallPy(tstate);

assert(frame != &entry_frame);

// GH-99729: We need to unlink the frame *before* clearing it:

_PyInterpreterFrame *dying = frame;

frame = cframe.current_frame = dying->previous;

_PyEvalFrameClearAndPop(tstate, dying);

frame->prev_instr += frame->return_offset;

_PyFrame_StackPush(frame, retval);

goto resume_frame;

#line 970 "Python/generated_cases.c.h"

}

TARGET(INSTRUMENTED_RETURN_CONST) {

#line 683 "Python/bytecodes.c"

PyObject *retval = GETITEM(frame->f_code->co_consts, oparg);

int err = _Py_call_instrumentation_arg(

tstate, PY_MONITORING_EVENT_PY_RETURN,

frame, next_instr-1, retval);

if (err) goto error;

Py_INCREF(retval);

assert(EMPTY());

_PyFrame_SetStackPointer(frame, stack_pointer);

_Py_LeaveRecursiveCallPy(tstate);

assert(frame != &entry_frame);

// GH-99729: We need to unlink the frame *before* clearing it:

_PyInterpreterFrame *dying = frame;

frame = cframe.current_frame = dying->previous;

_PyEvalFrameClearAndPop(tstate, dying);

frame->prev_instr += frame->return_offset;

_PyFrame_StackPush(frame, retval);

goto resume_frame;

#line 992 "Python/generated_cases.c.h"

}

TARGET(GET_AITER) {

PyObject *obj = stack_pointer[-1];

PyObject *iter;

#line 703 "Python/bytecodes.c"

unaryfunc getter = NULL;

PyTypeObject *type = Py_TYPE(obj);