// 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 (opcode)

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

// _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_FT

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

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

_PyFrame_SetStackPointer(frame, stack_pointer);

_PyStackRef tmp = lhs;

lhs = res;

stack_pointer[-2] = lhs;

PyStackRef_CLOSE(tmp);

tmp = rhs;

rhs = PyStackRef_NULL;

stack_pointer[-1] = rhs;

PyStackRef_CLOSE(tmp);

stack_pointer = _PyFrame_GetStackPointer(frame);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

}

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;

// _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);

if (PyStackRef_IsNull(res)) {

JUMP_TO_LABEL(pop_2_error);

}

}

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyLong_CheckExact(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_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_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));

STAT_INC(BINARY_OP, hit);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);

PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);

if (res_o == NULL) {

JUMP_TO_LABEL(pop_2_error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

}

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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;

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

PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);

PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);

if (res_o == NULL) {

JUMP_TO_LABEL(pop_2_error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

}

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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;

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

_PyStackRef tmp = right;

right = PyStackRef_NULL;

stack_pointer[-1] = right;

PyStackRef_CLOSE(tmp);

tmp = left;

left = PyStackRef_NULL;

stack_pointer[-2] = left;

PyStackRef_CLOSE(tmp);

stack_pointer = _PyFrame_GetStackPointer(frame);

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

if (res_o == NULL) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

}

stack_pointer[0] = res;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

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;

// _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 = CURRENT_OPERAND0();

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

PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);

PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);

PyObject *right_o = PyStackRef_AsPyObjectSteal(right);

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

_PyFrame_SetStackPointer(frame, stack_pointer);

PyUnicode_Append(&temp, right_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

*target_local = PyStackRef_FromPyObjectSteal(temp);

_PyFrame_SetStackPointer(frame, stack_pointer);

Py_DECREF(right_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (PyStackRef_IsNull(*target_local)) {

JUMP_TO_LABEL(error);

}

#if TIER_ONE

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

SKIP_OVER(1);

#endif

}

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;

// _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);

if (PyStackRef_IsNull(res)) {

JUMP_TO_LABEL(pop_2_error);

}

}

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyLong_CheckExact(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_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_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));

STAT_INC(BINARY_OP, hit);

_PyFrame_SetStackPointer(frame, stack_pointer);

PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);

stack_pointer = _PyFrame_GetStackPointer(frame);

PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);

PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);

if (res_o == NULL) {

JUMP_TO_LABEL(pop_2_error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

}

stack_pointer[-2] = res;

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

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;

// _GUARD_NOS_DICT

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyDict_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(PyDict_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);

}

_PyFrame_SetStackPointer(frame, stack_pointer);

_PyStackRef tmp = sub_st;

sub_st = PyStackRef_NULL;

stack_pointer[-1] = sub_st;

PyStackRef_CLOSE(tmp);

tmp = dict_st;

dict_st = PyStackRef_NULL;

stack_pointer[-2] = dict_st;

PyStackRef_CLOSE(tmp);

stack_pointer = _PyFrame_GetStackPointer(frame);

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

if (rc <= 0) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

}

stack_pointer[0] = res;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

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;

_PyInterpreterFrame *new_frame;

/* Skip 5 cache entries */

// _CHECK_PEP_523

{

if (tstate->interp->eval_frame) {

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

STAT_INC(BINARY_OP, hit);

}

// _BINARY_OP_SUBSCR_INIT_CALL

{

sub = stack_pointer[-1];

new_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame);

new_frame->localsplus[0] = container;

new_frame->localsplus[1] = sub;

frame->return_offset = 6u ;

}

// _PUSH_FRAME

{

assert(tstate->interp->eval_frame == NULL);

_PyInterpreterFrame *temp = new_frame;

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

_PyFrame_SetStackPointer(frame, stack_pointer);

assert(new_frame->previous == frame || new_frame->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;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyLong_CheckExact(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);

_PyFrame_SetStackPointer(frame, stack_pointer);

_PyStackRef tmp = list_st;

list_st = res;

stack_pointer[-2] = list_st;

PyStackRef_CLOSE(tmp);

tmp = sub_st;

sub_st = PyStackRef_NULL;

stack_pointer[-1] = sub_st;

PyStackRef_CLOSE(tmp);

stack_pointer = _PyFrame_GetStackPointer(frame);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

}

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;

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

_PyFrame_SetStackPointer(frame, stack_pointer);

_PyStackRef tmp = sub_st;

sub_st = PyStackRef_NULL;

stack_pointer[-1] = sub_st;

PyStackRef_CLOSE(tmp);

tmp = list_st;

list_st = PyStackRef_NULL;

stack_pointer[-2] = list_st;

PyStackRef_CLOSE(tmp);

stack_pointer = _PyFrame_GetStackPointer(frame);

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

if (res_o == NULL) {

JUMP_TO_LABEL(error);

}

res = PyStackRef_FromPyObjectSteal(res_o);

}

stack_pointer[0] = res;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

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;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyLong_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_SUBSCR_STR_INT

{

sub_st = value;

str_st = nos;

PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);

PyObject *str = PyStackRef_AsPyObjectBorrow(str_st);

assert(PyLong_CheckExact(sub));

assert(PyUnicode_CheckExact(str));

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

if (PyUnicode_GET_LENGTH(str) <= index) {

UPDATE_MISS_STATS(BINARY_OP);

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

JUMP_TO_PREDICTED(BINARY_OP);

}

Py_UCS4 c = PyUnicode_READ_CHAR(str, index);

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

UPDATE_MISS_STATS(BINARY_OP);

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

JUMP_TO_PREDICTED(BINARY_OP);

}

STAT_INC(BINARY_OP, hit);

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

PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);

stack_pointer += -2;

assert(WITHIN_STACK_BOUNDS());

_PyFrame_SetStackPointer(frame, stack_pointer);

PyStackRef_CLOSE(str_st);

stack_pointer = _PyFrame_GetStackPointer(frame);

res = PyStackRef_FromPyObjectImmortal(res_o);

}

stack_pointer[0] = res;

stack_pointer += 1;

assert(WITHIN_STACK_BOUNDS());

DISPATCH();

}

TARGET(BINARY_OP_SUBSCR_TUPLE_INT) {

#if Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBSCR_TUPLE_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_TUPLE_INT);

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

_PyStackRef value;

_PyStackRef nos;

_PyStackRef tuple_st;

_PyStackRef sub_st;

_PyStackRef res;

// _GUARD_TOS_INT

{

value = stack_pointer[-1];

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

if (!PyLong_CheckExact(value_o)) {

UPDATE_MISS_STATS(BINARY_OP);

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

JUMP_TO_PREDICTED(BINARY_OP);

}

}

// _GUARD_NOS_TUPLE

{

nos = stack_pointer[-2];

PyObject *o = PyStackRef_AsPyObjectBorrow(nos);

if (!PyTuple_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_TUPLE_INT

{

sub_st = value;

tuple_st = nos;

PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);

PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st);

assert(PyLong_CheckExact(sub));

assert(PyTuple_CheckExact(tuple));

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

if (index >= PyTuple_GET_SIZE(tuple)) {

UPDATE_MISS_STATS(BINARY_OP);

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

JUMP_TO_PREDICTED(BINARY_OP);

}

STAT_INC(BINARY_OP, hit);

PyObject *res_o = PyTuple_GET_ITEM(tuple, index);

assert(res_o != NULL);

PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);

res = PyStackRef_FromPyObjectNew(res_o);

stack_pointer += -1;

assert(WITHIN_STACK_BOUNDS());

_PyFrame_SetStackPointer(frame, stack_pointer);

_PyStackRef tmp = tuple_st;

tuple_st = res;

stack_pointer[-1] = tuple_st;

PyStackRef_CLOSE(tmp);

stack_pointer = _PyFrame_GetStackPointer(frame);

}

DISPATCH();

}

TARGET(BINARY_OP_SUBTRACT_FLOAT) {

#if Py_TAIL_CALL_INTERP

int opcode = BINARY_OP_SUBTRACT_FLOAT;

(void)(opcode);

#endif

_Py_CODEUNIT* const this_instr = next_instr;

(void)this_instr;

frame->instr_ptr = next_instr;

next_instr += 6;