// This file is generated by Tools/cases_generator/tier1_generator.py

// from:

// Python/bytecodes.c

// Do not edit!

#ifdef TIER_TWO

#error "This file is for Tier 1 only"

#endif

#define TIER_ONE 1

#if !_Py_TAIL_CALL_INTERP

#if !USE_COMPUTED_GOTOS

dispatch_opcode:

switch (dispatch_code)

#endif

{

#endif /* _Py_TAIL_CALL_INTERP */

/* BEGIN INSTRUCTIONS */

TARGET(BINARY_OP) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP;

(void)(opcode);

#endif

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP);

PREDICTED_BINARY_OP:;

_Py_CODEUNIT* const this_instr = next_instr - 6;

(void)this_instr;

_PyStackRef lhs;

_PyStackRef rhs;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

_PyStackRef value;

// _SPECIALIZE_BINARY_OP

{

rhs = stack_pointer[-1];

lhs = stack_pointer[-2];

uint16_t counter = read_u16(&this_instr[1].cache);

(void)counter;

#if ENABLE_SPECIALIZATION

if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {

next_instr = this_instr;

_PyFrame_SetStackPointer(frame, stack_pointer);

_Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY);

stack_pointer = _PyFrame_GetStackPointer(frame);

DISPATCH_SAME_OPARG();

}

OPCODE_DEFERRED_INC(BINARY_OP);

ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter);

#endif /* ENABLE_SPECIALIZATION */

assert(NB_ADD <= oparg);

assert(oparg <= NB_OPARG_LAST);

}

/* Skip 4 cache entries */

// _BINARY_OP

{

PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs);

PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs);

assert(_PyEval_BinaryOps[oparg]);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (res_o == NULL) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

l = lhs;

r = rhs;

}

// _POP_TOP

{

value = r;

stack_pointer[-2] = res;

stack_pointer[-1] = l;

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

// _POP_TOP

{

value = l;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

DISPATCH();

}

TARGET(BINARY_OP_ADD_FLOAT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_ADD_FLOAT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_ADD_FLOAT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

// _GUARD_TOS_FLOAT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyFloat_CheckExact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_FLOAT

{

left = stack_pointer[-2];

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

if (!PyFloat_CheckExact(left_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_ADD_FLOAT

{

right = value;

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

assert(PyFloat_CheckExact(left_o));

assert(PyFloat_CheckExact(right_o));

STAT_INC(BINARY_OP, hit);

double dres =

((PyFloatObject *)left_o)->ob_fval +

((PyFloatObject *)right_o)->ob_fval;

res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));

if (PyStackRef_IsNull(res)) {

JUMP_TO_LABEL(error);

}

l = left;

r = right;

}

// _POP_TOP_FLOAT

{

value = r;

assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc);

}

// _POP_TOP_FLOAT

{

value = l;

assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc);

}

stack_pointer[-2] = res;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

DISPATCH();

}

TARGET(BINARY_OP_ADD_INT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_ADD_INT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_ADD_INT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!_PyLong_CheckExactAndCompact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_INT

{

left = stack_pointer[-2];

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

if (!_PyLong_CheckExactAndCompact(left_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_ADD_INT

{

right = value;

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

assert(PyLong_CheckExact(left_o));

assert(PyLong_CheckExact(right_o));

assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o));

STAT_INC(BINARY_OP, hit);

res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);

if (PyStackRef_IsNull(res)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

l = left;

r = right;

}

// _POP_TOP_INT

{

value = r;

assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc);

}

// _POP_TOP_INT

{

value = l;

assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc);

}

stack_pointer[-2] = res;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

DISPATCH();

}

TARGET(BINARY_OP_ADD_UNICODE) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_ADD_UNICODE;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_ADD_UNICODE);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef nos;

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

// _GUARD_TOS_UNICODE

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyUnicode_CheckExact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_UNICODE

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyUnicode_CheckExact(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_ADD_UNICODE

{

right = value;

left = nos;

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

assert(PyUnicode_CheckExact(left_o));

assert(PyUnicode_CheckExact(right_o));

STAT_INC(BINARY_OP, hit);

PyObject *res_o = PyUnicode_Concat(left_o, right_o);

res = PyStackRef_FromPyObjectSteal(res_o);

if (PyStackRef_IsNull(res)) {

JUMP_TO_LABEL(error);

}

l = left;

r = right;

}

// _POP_TOP_UNICODE

{

value = r;

assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc);

}

// _POP_TOP_UNICODE

{

value = l;

assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc);

}

stack_pointer[-2] = res;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

DISPATCH();

}

TARGET(BINARY_OP_EXTEND) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_EXTEND;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_EXTEND);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

_PyStackRef value;

/* Skip 1 cache entry */

// _GUARD_BINARY_OP_EXTEND

{

right = stack_pointer[-1];

left = stack_pointer[-2];

PyObject *descr = read_obj(&this_instr[2].cache);

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr;

assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5);

assert(d && d->guard);

_PyFrame_SetStackPointer(frame, stack_pointer);

int res = d->guard(left_o, right_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (!res) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip -4 cache entry */

// _BINARY_OP_EXTEND

{

PyObject *descr = read_obj(&this_instr[2].cache);

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5);

_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr;

STAT_INC(BINARY_OP, hit);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyObject *res_o = d->action(left_o, right_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (res_o == NULL) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

l = left;

r = right;

}

// _POP_TOP

{

value = r;

stack_pointer[-2] = res;

stack_pointer[-1] = l;

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

// _POP_TOP

{

value = l;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

DISPATCH();

}

TARGET(BINARY_OP_INPLACE_ADD_UNICODE) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_INPLACE_ADD_UNICODE;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_INPLACE_ADD_UNICODE);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef nos;

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

// _GUARD_TOS_UNICODE

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyUnicode_CheckExact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_UNICODE

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyUnicode_CheckExact(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_INPLACE_ADD_UNICODE

{

right = value;

left = nos;

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

assert(PyUnicode_CheckExact(left_o));

assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(right)));

int next_oparg;

#if TIER_ONE

assert(next_instr->op.code == STORE_FAST);

next_oparg = next_instr->op.arg;

#else

next_oparg = (int)CURRENT_OPERAND0_16();

#endif

_PyStackRef *target_local = &GETLOCAL(next_oparg);

assert(PyUnicode_CheckExact(left_o));

if (PyStackRef_AsPyObjectBorrow(*target_local) != left_o) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

STAT_INC(BINARY_OP, hit);

assert(Py_REFCNT(left_o) >= 2 || !PyStackRef_IsHeapSafe(left));

PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);

PyObject *right_o = PyStackRef_AsPyObjectSteal(right);

PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);

stack_pointer += -2;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyUnicode_Append(&temp, right_o);

_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);

stack_pointer = _PyFrame_GetStackPointer(frame);

*target_local = PyStackRef_NULL;

if (temp == NULL) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(temp);

}

stack_pointer[0] = res;

stack_pointer += 1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

DISPATCH();

}

TARGET(BINARY_OP_MULTIPLY_FLOAT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_MULTIPLY_FLOAT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_MULTIPLY_FLOAT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

// _GUARD_TOS_FLOAT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyFloat_CheckExact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_FLOAT

{

left = stack_pointer[-2];

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

if (!PyFloat_CheckExact(left_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_MULTIPLY_FLOAT

{

right = value;

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

assert(PyFloat_CheckExact(left_o));

assert(PyFloat_CheckExact(right_o));

STAT_INC(BINARY_OP, hit);

double dres =

((PyFloatObject *)left_o)->ob_fval *

((PyFloatObject *)right_o)->ob_fval;

res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));

if (PyStackRef_IsNull(res)) {

JUMP_TO_LABEL(error);

}

l = left;

r = right;

}

// _POP_TOP_FLOAT

{

value = r;

assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc);

}

// _POP_TOP_FLOAT

{

value = l;

assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc);

}

stack_pointer[-2] = res;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

DISPATCH();

}

TARGET(BINARY_OP_MULTIPLY_INT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_MULTIPLY_INT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_MULTIPLY_INT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef left;

_PyStackRef right;

_PyStackRef res;

_PyStackRef l;

_PyStackRef r;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!_PyLong_CheckExactAndCompact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_INT

{

left = stack_pointer[-2];

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

if (!_PyLong_CheckExactAndCompact(left_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_MULTIPLY_INT

{

right = value;

PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);

PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);

assert(PyLong_CheckExact(left_o));

assert(PyLong_CheckExact(right_o));

assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o));

STAT_INC(BINARY_OP, hit);

res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);

if (PyStackRef_IsNull(res)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

l = left;

r = right;

}

// _POP_TOP_INT

{

value = r;

assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc);

}

// _POP_TOP_INT

{

value = l;

assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc);

}

stack_pointer[-2] = res;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

DISPATCH();

}

TARGET(BINARY_OP_SUBSCR_DICT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBSCR_DICT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_SUBSCR_DICT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef nos;

_PyStackRef dict_st;

_PyStackRef sub_st;

_PyStackRef res;

_PyStackRef ds;

_PyStackRef ss;

_PyStackRef value;

// _GUARD_NOS_ANY_DICT

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyAnyDict_CheckExact(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_SUBSCR_DICT

{

sub_st = stack_pointer[-1];

dict_st = nos;

PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);

PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st);

assert(PyAnyDict_CheckExact(dict));

STAT_INC(BINARY_OP, hit);

PyObject *res_o;

_PyFrame_SetStackPointer(frame, stack_pointer);

int rc = PyDict_GetItemRef(dict, sub, &res_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (rc == 0) {

_PyFrame_SetStackPointer(frame, stack_pointer);

_PyErr_SetKeyError(sub);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

if (rc <= 0) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

ds = dict_st;

ss = sub_st;

}

// _POP_TOP

{

value = ss;

stack_pointer[-2] = res;

stack_pointer[-1] = ds;

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

// _POP_TOP

{

value = ds;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

DISPATCH();

}

TARGET(BINARY_OP_SUBSCR_GETITEM) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBSCR_GETITEM;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_SUBSCR_GETITEM);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef container;

_PyStackRef getitem;

_PyStackRef sub;

_PyStackRef new_frame;

/* Skip 5 cache entries */

// _CHECK_PEP_523

{

if (IS_PEP523_HOOKED(tstate)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _BINARY_OP_SUBSCR_CHECK_FUNC

{

container = stack_pointer[-2];

PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container));

if (!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;

PyObject *getitem_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(ht->_spec_cache.getitem);

if (getitem_o == NULL) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

assert(PyFunction_Check(getitem_o));

uint32_t cached_version = FT_ATOMIC_LOAD_UINT32_RELAXED(ht->_spec_cache.getitem_version);

if (((PyFunctionObject *)getitem_o)->func_version != cached_version) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(getitem_o);

assert(code->co_argcount == 2);

if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

getitem = PyStackRef_FromPyObjectNew(getitem_o);

}

// _BINARY_OP_SUBSCR_INIT_CALL

{

sub = stack_pointer[-1];

STAT_INC(BINARY_OP, hit);

_PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame);

pushed_frame->localsplus[0] = container;

pushed_frame->localsplus[1] = sub;

frame->return_offset = 6u ;

new_frame = PyStackRef_Wrap(pushed_frame);

}

// _PUSH_FRAME

{

assert(!IS_PEP523_HOOKED(tstate));

_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);

stack_pointer += -2;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

assert(temp->previous == frame || temp->previous->previous == frame);

CALL_STAT_INC(inlined_py_calls);

frame = tstate->current_frame = temp;

tstate->py_recursion_remaining--;

LOAD_SP();

LOAD_IP(0);

LLTRACE_RESUME_FRAME();

}

DISPATCH();

}

TARGET(BINARY_OP_SUBSCR_LIST_INT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBSCR_LIST_INT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_SUBSCR_LIST_INT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef nos;

_PyStackRef list_st;

_PyStackRef sub_st;

_PyStackRef res;

_PyStackRef ls;

_PyStackRef ss;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!_PyLong_CheckExactAndCompact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_LIST

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyList_CheckExact(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_SUBSCR_LIST_INT

{

sub_st = value;

list_st = nos;

PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);

PyObject *list = PyStackRef_AsPyObjectBorrow(list_st);

assert(PyLong_CheckExact(sub));

assert(PyList_CheckExact(list));

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

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

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

#ifdef Py_GIL_DISABLED

_PyFrame_SetStackPointer(frame, stack_pointer);

PyObject *res_o = _PyList_GetItemRef((PyListObject*)list, index);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (res_o == NULL) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

STAT_INC(BINARY_OP, hit);

res = PyStackRef_FromPyObjectSteal(res_o);

#else

if (index >= PyList_GET_SIZE(list)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

STAT_INC(BINARY_OP, hit);

PyObject *res_o = PyList_GET_ITEM(list, index);

assert(res_o != NULL);

res = PyStackRef_FromPyObjectNew(res_o);

#endif

STAT_INC(BINARY_OP, hit);

ls = list_st;

ss = sub_st;

}

// _POP_TOP_INT

{

value = ss;

assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value)));

PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc);

}

// _POP_TOP

{

value = ls;

stack_pointer[-2] = res;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

DISPATCH();

}

TARGET(BINARY_OP_SUBSCR_LIST_SLICE) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBSCR_LIST_SLICE;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_SUBSCR_LIST_SLICE);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef tos;

_PyStackRef nos;

_PyStackRef list_st;

_PyStackRef sub_st;

_PyStackRef res;

_PyStackRef ls;

_PyStackRef ss;

_PyStackRef value;

// _GUARD_TOS_SLICE

{

tos = stack_pointer[-1];

PyObject *o = PyStackRef_AsPyObjectBorrow(tos);

if (!PySlice_Check(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_LIST

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyList_CheckExact(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

/* Skip 5 cache entries */

// _BINARY_OP_SUBSCR_LIST_SLICE

{

sub_st = tos;

list_st = nos;

PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);

PyObject *list = PyStackRef_AsPyObjectBorrow(list_st);

assert(PySlice_Check(sub));

assert(PyList_CheckExact(list));

_PyFrame_SetStackPointer(frame, stack_pointer);

PyObject *res_o = _PyList_SliceSubscript(list, sub);

stack_pointer = _PyFrame_GetStackPointer(frame);

STAT_INC(BINARY_OP, hit);

if (res_o == NULL) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

ls = list_st;

ss = sub_st;

}

// _POP_TOP

{

value = ss;

stack_pointer[-2] = res;

stack_pointer[-1] = ls;

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

// _POP_TOP

{

value = ls;

stack_pointer += -1;

ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_XCLOSE(value);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

DISPATCH();

}

TARGET(BINARY_OP_SUBSCR_STR_INT) {

#if _Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBSCR_STR_INT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;

INSTRUCTION_STATS(BINARY_OP_SUBSCR_STR_INT);

static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5, "incorrect cache size");

_PyStackRef value;

_PyStackRef nos;

_PyStackRef str_st;

_PyStackRef sub_st;

_PyStackRef res;

_PyStackRef s;

_PyStackRef i;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!_PyLong_CheckExactAndCompact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_COMPACT_ASCII

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyUnicode_CheckExact(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}

if (!PyUnicode_IS_COMPACT_ASCII(o)) {

UPDATE_MISS_STATS(BINARY_OP);

assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));

JUMP_TO_PREDICTED(BINARY_OP);

}