// This file is generated by Tools/cases_generator/tier2_generator.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__)

if (_Py_emscripten_signal_clock == 0) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

_Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING;

#endif

uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker);

uintptr_t version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);

assert((version & _PY_EVAL_EVENTS_MASK) == 0);

if (eval_breaker != version) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

break;

}

/* _INSTRUMENTED_RESUME is not a viable micro-op for tier 2 because it is instrumented */

case _LOAD_FAST_CHECK: {

PyObject *value;

oparg = CURRENT_OPARG();

value = GETLOCAL(oparg);

if (value == NULL) {

_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,

UNBOUNDLOCAL_ERROR_MSG,

PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)

);

if (1) JUMP_TO_ERROR();

}

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_0: {

PyObject *value;

oparg = 0;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_1: {

PyObject *value;

oparg = 1;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_2: {

PyObject *value;

oparg = 2;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_3: {

PyObject *value;

oparg = 3;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_4: {

PyObject *value;

oparg = 4;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_5: {

PyObject *value;

oparg = 5;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_6: {

PyObject *value;

oparg = 6;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_7: {

PyObject *value;

oparg = 7;

assert(oparg == CURRENT_OPARG());

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST: {

PyObject *value;

oparg = CURRENT_OPARG();

value = GETLOCAL(oparg);

assert(value != NULL);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_FAST_AND_CLEAR: {

PyObject *value;

oparg = CURRENT_OPARG();

value = GETLOCAL(oparg);

// do not use SETLOCAL here, it decrefs the old value

GETLOCAL(oparg) = NULL;

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _LOAD_CONST: {

PyObject *value;

oparg = CURRENT_OPARG();

value = GETITEM(FRAME_CO_CONSTS, oparg);

Py_INCREF(value);

stack_pointer[0] = value;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_0: {

PyObject *value;

oparg = 0;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_1: {

PyObject *value;

oparg = 1;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_2: {

PyObject *value;

oparg = 2;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_3: {

PyObject *value;

oparg = 3;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_4: {

PyObject *value;

oparg = 4;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_5: {

PyObject *value;

oparg = 5;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_6: {

PyObject *value;

oparg = 6;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST_7: {

PyObject *value;

oparg = 7;

assert(oparg == CURRENT_OPARG());

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_FAST: {

PyObject *value;

oparg = CURRENT_OPARG();

value = stack_pointer[-1];

SETLOCAL(oparg, value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _POP_TOP: {

PyObject *value;

value = stack_pointer[-1];

Py_DECREF(value);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _PUSH_NULL: {

PyObject *res;

res = NULL;

stack_pointer[0] = res;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _END_SEND: {

PyObject *value;

PyObject *receiver;

value = stack_pointer[-1];

receiver = stack_pointer[-2];

Py_DECREF(receiver);

stack_pointer[-2] = value;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _UNARY_NEGATIVE: {

PyObject *value;

PyObject *res;

value = stack_pointer[-1];

res = PyNumber_Negative(value);

Py_DECREF(value);

if (res == NULL) JUMP_TO_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];

int err = PyObject_IsTrue(value);

Py_DECREF(value);

if (err < 0) JUMP_TO_ERROR();

res = err ? Py_True : Py_False;

stack_pointer[-1] = res;

break;

}

case _TO_BOOL_BOOL: {

PyObject *value;

value = stack_pointer[-1];

if (!PyBool_Check(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

STAT_INC(TO_BOOL, hit);

break;

}

case _TO_BOOL_INT: {

PyObject *value;

PyObject *res;

value = stack_pointer[-1];

if (!PyLong_CheckExact(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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

if (!PyList_CheckExact(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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:

if (!Py_IsNone(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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

if (!PyUnicode_CheckExact(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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

PyObject *value;

PyObject *res;

value = stack_pointer[-1];

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

stack_pointer[-1] = res;

break;

}

case _GUARD_BOTH_INT: {

PyObject *right;

PyObject *left;

right = stack_pointer[-1];

left = stack_pointer[-2];

if (!PyLong_CheckExact(left)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyLong_CheckExact(right)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

break;

}

case _GUARD_NOS_INT: {

PyObject *left;

left = stack_pointer[-2];

if (!PyLong_CheckExact(left)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

break;

}

case _GUARD_TOS_INT: {

PyObject *value;

value = stack_pointer[-1];

if (!PyLong_CheckExact(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _GUARD_BOTH_FLOAT: {

PyObject *right;

PyObject *left;

right = stack_pointer[-1];

left = stack_pointer[-2];

if (!PyFloat_CheckExact(left)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyFloat_CheckExact(right)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

break;

}

case _GUARD_NOS_FLOAT: {

PyObject *left;

left = stack_pointer[-2];

if (!PyFloat_CheckExact(left)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

break;

}

case _GUARD_TOS_FLOAT: {

PyObject *value;

value = stack_pointer[-1];

if (!PyFloat_CheckExact(value)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _GUARD_BOTH_UNICODE: {

PyObject *right;

PyObject *left;

right = stack_pointer[-1];

left = stack_pointer[-2];

if (!PyUnicode_CheckExact(left)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyUnicode_CheckExact(right)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer[-3] = res;

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer += -4;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _BINARY_SUBSCR_LIST_INT: {

PyObject *sub;

PyObject *list;

PyObject *res;

sub = stack_pointer[-1];

list = stack_pointer[-2];

if (!PyLong_CheckExact(sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyList_CheckExact(list)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

// Deopt unless 0 <= sub < PyList_Size(list)

if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];

if (index >= PyList_GET_SIZE(list)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _BINARY_SUBSCR_STR_INT: {

PyObject *sub;

PyObject *str;

PyObject *res;

sub = stack_pointer[-1];

str = stack_pointer[-2];

if (!PyLong_CheckExact(sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyUnicode_CheckExact(str)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];

if (PyUnicode_GET_LENGTH(str) <= index) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

// Specialize for reading an ASCII character from any string:

Py_UCS4 c = PyUnicode_READ_CHAR(str, index);

if (Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

STAT_INC(BINARY_SUBSCR, hit);

res = (PyObject*)&_Py_SINGLETON(strings).ascii[c];

_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);

Py_DECREF(str);

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _BINARY_SUBSCR_TUPLE_INT: {

PyObject *sub;

PyObject *tuple;

PyObject *res;

sub = stack_pointer[-1];

tuple = stack_pointer[-2];

if (!PyLong_CheckExact(sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyTuple_CheckExact(tuple)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

// Deopt unless 0 <= sub < PyTuple_Size(list)

if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];

if (index >= PyTuple_GET_SIZE(tuple)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _BINARY_SUBSCR_DICT: {

PyObject *sub;

PyObject *dict;

PyObject *res;

sub = stack_pointer[-1];

dict = stack_pointer[-2];

if (!PyDict_CheckExact(dict)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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

// not found or error

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

/* _BINARY_SUBSCR_GETITEM is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */

case _LIST_APPEND: {

PyObject *v;

PyObject *list;

oparg = CURRENT_OPARG();

v = stack_pointer[-1];

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

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

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _SET_ADD: {

PyObject *v;

PyObject *set;

oparg = CURRENT_OPARG();

v = stack_pointer[-1];

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

int err = PySet_Add(set, v);

Py_DECREF(v);

if (err) JUMP_TO_ERROR();

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer += -3;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_SUBSCR_LIST_INT: {

PyObject *sub;

PyObject *list;

PyObject *value;

sub = stack_pointer[-1];

list = stack_pointer[-2];

value = stack_pointer[-3];

if (!PyLong_CheckExact(sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

if (!PyList_CheckExact(list)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

// Ensure nonnegative, zero-or-one-digit ints.

if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];

// Ensure index < len(list)

if (index >= PyList_GET_SIZE(list)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

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_pointer += -3;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _STORE_SUBSCR_DICT: {

PyObject *sub;

PyObject *dict;

PyObject *value;

sub = stack_pointer[-1];

dict = stack_pointer[-2];

value = stack_pointer[-3];

if (!PyDict_CheckExact(dict)) {

UOP_STAT_INC(uopcode, miss);

JUMP_TO_JUMP_TARGET();

}

STAT_INC(STORE_SUBSCR, hit);

int err = _PyDict_SetItem_Take2((PyDictObject *)dict, sub, value);

Py_DECREF(dict);

if (err) JUMP_TO_ERROR();

stack_pointer += -3;

assert(WITHIN_STACK_BOUNDS());

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

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

break;

}

case _CALL_INTRINSIC_1: {

PyObject *value;

PyObject *res;

oparg = CURRENT_OPARG();

value = stack_pointer[-1];

assert(oparg <= MAX_INTRINSIC_1);

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

Py_DECREF(value);

if (res == NULL) JUMP_TO_ERROR();

stack_pointer[-1] = res;

break;

}